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

Mikl___ · 29 окт 2026 в 09:07

Работа с данными и памятью
Преобразование данных

Если мы попытаемся использовать в инструкции два несовместимых по размеру операнда, то мы получим ошибку. Например:

Код (ASM):

.data

num byte 17

.code

main proc

mov eax, num

ret

main endp

end

В данном случае в 32-разрядный регистр EAX мы пытаемся поместить значение 8-разрядной переменной num. И в принципе то переменная num вполне может поместить в EAX, но ассемблер требует, чтобы оба операнда были одного размера. Соответственно программа не скомпилируется, и мы получим ошибку.
Чтобы решить данную проблему, мы можем применять преобразование типов. Преобзование имеет следующую форму:

Код (ASM):

тип ptr значение

Сначала указывается тип данных, в который мы преобразуем (byte, word, dword и т.д.). Далее идет оператор ptr, после которого указывается преобразуемое значение. Например, изменим предыдущую программу, применив преобразование:

Код (ASM):

.data

num byte 17

.code

main proc

mov eax, dword ptr num

ret

main endp

end

Выражение dword ptr num означает, что значение num преобразуется к типу dword.
Подобным образом можно преобразовывать константы

Код (ASM):

num = 19

.code

main proc

mov eax, dword ptr num

ret

main endp

end

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

Код (ASM):

.data

num word 0FFFEh

.code

main proc

mov al, byte ptr num

ret

main endp

end

Здесь 16-разрядную переменную num (равная 0FFFEh или 65534 в десятичной системе) преобразуем в 8-разрядный тип byte для помещения в регистр AL. При преобразовании будет из 16 бит в 8 бит в num будет отброшен старший бит и останется число FEh или 254.
Если же значение преобразуемой переменной укладывается в диапазон значений требуемого типа, тогда проблем с преобразованием никаких нет.

Mikl___ · 29 окт 2026 в 13:32

Работа с данными и памятью
Символы
Как и все данные, символы в памяти компьютера представляют набор битов - единиц и нулей, упорядоченных определенным образом. Большинство компьютеров для представления одного символа используют 1 или 2 байта. Windows, macOS, FreeBSD и Linux используют для символов кодировку ASCII или Unicode.
Преобразование чисел в символы
Таблица ASCII (American Standard Code for Information Interchange) представляет один из наиболее простых и популярных способов кодирования символов. ASCII представляет таблицу кодировки символов, в которой каждому символу соответствует определенное число. Например, латинской букве A соответствует число 65, а букве B - число 66. Более того цифровые символы имеет свои собственные числовые коды. Например, символу 0 соответствует число 48, символу 1 - число 49 и т.д. Каждый отдельный символ из таблицы ASCII представляет 1 байт.
Таблица символов ASCII
Первые 32 символа - управляющие последовательности.

DEC HEX BIN Символ Описание DEC HEX BIN Символ Описание
0 00 00000000 NUL Ноль/нулевой байт 16 10 00010000 DLE Ключ связи данных
1 01 00000001 SOH Начало заголовка 17 11 00010001 DC1 Управление устройством 1
2 02 00000010 STX Начало текста 18 12 00010010 DC2 Управление устройством 2
3 03 00000011 ETX Конец текста 19 13 00010011 DC3 Управление устройством 3
4 04 00000100 EOT Конец передачи 20 14 00010100 DC4 Управление устройством 4
5 05 00000101 ENQ запрос 21 15 00010101 NAK Отрицательное подтверждение
6 06 00000110 ACK Подтверждение 22 16 00000000 SYN Синхронизация
7 07 00000111 BEL Сигнал/звонок 23 17 00000000 ETB Конец передаваемого блока
8 08 00001000 BS Шаг назад 24 18 00000000 CAN Отмена
9 09 00001001 HT Горизонтальная табуляция 25 19 00000000 EM Конец среды
10 0A 00001010 LF Перевод строки 26 1A 00000000 SUB Замена
11 0B 00001011 VT Вертикальная табуляция 27 1B 00000000 ESC Выход
12 0C 00001100 FF Новая страница 28 1C 00000000 FS Разделитель файлов
13 0D 00001101 CR Возврат каретки 29 1D 00000000 GS Разделитель групп
14 0E 00001110 SO Выключить сдвиг 30 1E 00011110 RS Разделитель записей
15 0F 00001111 SI Включить сдвиг 31 1F 00011111 US Разделитель модулей
Печатные символы

DEC HEX BIN Символ DEC HEX BIN Символ DEC HEX BIN Символ DEC HEX BIN Символ
32
20
00100000
пробел
56
38
00111000
8
80
50
01010000
P
104
68
01101000
h
33
21
00100001
!
57
39
00111001
9
81
51
01010001
Q
105
69
01101001
i
34
22
00100010
"
58
3A
00111010
:
82
52
01010010
R
106
6A
01101010
j
35 23 00100011 # 59 3B 00111011 ; 83 53 01010011 S 107 6B 01101011 k
36 24 00100100 $ 60 3C 00111100 < 84 54 01010100 T 108 6C 01101100 l
37 25 00100101 % 61 3D 00111101 = 85 55 01010101 U 109 6D 01101101 m
38 26 00100110 & 62 3E 00111110 > 86 56 01010110 V 110 6E 01101110 n
39 27 00100111 ' 63 3F 00111111 ? 87 57 01010111 W 111 6F 01101111 o
40 28 00101000 ( 64 40 01000000 @ 88 58 01011000 X 112 70 01110000 p
41 29 00101001 ) 65 41 01000001 A 89 59 01011001 Y 113 71 01110001 q
42 2A 00101010 * 66 42 01000010 B 90 5A 01011010 Z 114 72 01110010 r
43 2B 00101011 + 67 43 01000011 C 91 5B 01011011 [ 115 73 01110011 s
44 2C 00101100 , 68 44 01000100 D 92 5C 01011100 \ 116 74 01110100 t
45 2D 00101101 - 69 45 01000101 E 93 5D 01011101 ] 117 75 01110101 u
46 2E 00101110 . 70 46 01000110 F 94 5E 01011110 ^ 118 76 01110110 v
47 2F 00101111 / 71 47 01000111 G 95 5F 01011111 _ 119 77 01110111 w
48 30 00110000 0 72 48 01001000 H 96 60 01100000 ` 120 78 01111000 x
49 31 00110001 1 73 49 01001001 I 97 61 01100001 a 121 79 01111001 y
50 32 00110010 2 74 4A 01001010 J 98 62 01100010 b 122 7A 01111010 z
51 33 00110011 3 75 4B 01001011 K 99 63 01100011 c 123 7B 01111011 {
52 34 00110100 4 76 4C 01001100 L 100 64 01100100 d 124 7C 01111100 |
53 35 00110101 5 77 4D 01001101 M 101 65 01100101 e 125 7D 01111101 }
54 36 00110110 6 78 4E 01001110 N 102 66 01100110 f 126 7E 01111110 ~
55 37 00110111 7 79 4F 01001111 O 103 67 01100111 g 127 7F 01111111 DEL
Использование символов в ассемблере
Для определения символа или строки в ассемблере применяются кавычки. Можно использовать как одинарные кавычки, так и двойные:

Код (ASM):

.code

main proc

mov rax, "A" ; в регистре RAX числовой код символа A - 65

mov r8, 'B' ; в регистре R8 числовой код символа B - 66

ret

main endp

end

Для определения переменных, которые представляют символы ASCII, применяется тип byte:

Код (ASM):

.data

char byte "D" ; определяем один символ

.code

main proc

mov al, char ; в регистре AL числовой код символа D - 68

ret

main endp

end

Преобразование символов
Если мы посмотрим на таблицу ASCII, то увидим, что данная кодировка упрощает в некоторых случаях манипуляции с данными. Так, строчные буквы отличаются от заглавным установленным 6-м битом:
Буква A 01000001
Буква a 01100001
Соответственно, чтобы, например, перевести строчную букву в верхний регистр, достаточно снять шестой бит, а чтобы сделать заглавную букву строчной - наоборот, установить шестой бит. Для установки этого бита можно прибавить к числовому коду символа число 32, а для сброса этого бита - отнять от числового кода символа 32.
Или например, из таблицы мы видим, что числовой код цифровых символов начинается с 48 (или с 30 в 16-й сиситеме). Поэтому для перехода от числа к его символьному представлению и обратно мы можем прибавлять/вычитать 48.
Поскольку бинарный код чисел отличается от бинарного кода цифровых символов только старшим полубайтом, который у символов равен 3, то для перехода от символа к числу можно применить операцию AND, которая сбросит полубайт. А для перехода от числа к его символьному представлению можно установить полубайт с помощью операции OR. Например, преобразуем символ в число:

Код (ASM):

.code

main proc

mov rax, "2" ; числовой код цифры 2 равен 50 или 00110010

and rax, 0Fh ; убираем старший полубайт - 0011 с помощью маски 00001111

ret

main endp

end

Здесь преобразуем в число символ 2. В бинарной форме он равен 00110010. То есть нам надо сбросить первый полубайт 0011. Для этого применяем логическое умножение на число 0Fh, что в двоичной форме равно 00001111. То есть получим:
00110010 * 00001111 = 00000010
То есть получаем бинарное представление числа 2. Причем 0Fh - это маска, которая подходит для перехода от любого цифрового символа к числу для все числовых значений. Выполним обратный переход:

Код (ASM):

.code

main proc

mov rax, 2 ; числовой код 2 равен 00000010

or rax, 30h ; устанавливаем старший полубайт в 0011 с помощью маски 0011000

ret

main endp

end

Здесь преобразуем число 2 в соответствующий символ. В бинарной форме число 2 равно 00000010. То есть нам надо установить старший полубайт в 0011. Для этого применяем логическое сложение с числом 30h, что в двоичной форме равно 00110000. То есть получим:
00000010 + 00110000 = 00110010
То есть получаем число 50 - числовой код символа "2".
Подобным образом используя логического сложение с маской 20h можно получить из заглавной буквы строчную:

Код (ASM):

.code

main proc

mov rax, "A" ; числовой код символа A равен 65 или 01000001

or rax, 20h ; 01000001 + 00100000 = 97 - код символа a

ret

main endp

end

Используя логическое умножение на маску DFh или 11011111, можно перейти от строчной к заглавной букве:

Код (ASM):

.code

main proc

mov rax, "a" ; числовой код символа a равен 97 или 01100001

and rax, 0DFh ; 01100001 * 11011111 = 01000001 = 65 - код символа A

ret

main endp

end

Для той же цели можно прибавлять/вычитать 32 из кода символа:

Код (ASM):

.code

main proc

mov rax, "A" ; в RAX код 65

add rax, 32 ; 65 + 32 = 97 - код символа a

ret

main endp

end

Mikl___ · 29 окт 2026 в 13:54

Работа с данными и памятью
Режимы адресации. Косвенная адресация
Режимы адресации памяти x86-64 обеспечивают гибкий доступ к памяти, позволяя легко обращаться к переменным, массивам, записям, указателям и другим сложным типам данных. Архитектура x86-64 предоставляет несколько режимов адресации:

Адресация регистров

Адресация памяти относительно счетчика команд (PC-relative memory addressing)

Косвенная адресация регистров ([reg64])

Косвенная адресация регистров со смещением ([reg64 + offset])

Косвенная адресация регистров со смещением и масштабированием ([reg64 + offset + reg64 * scale])

Режим адресации регистров предоставляет доступ к регистрам общего назначения. Это стандартное обращение к регистрам процессора:

Код (ASM):

mov rax, rdx

Регистры представляют самый быстрый тип памяти компьютера. Инструкции, которые используют регистры, короче и быстрее, чем те, которые обращаются к памяти. Поскольку для большинства вычислений требуется по крайней мере один регистр, режим адресации регистров популярен в ассемблере x86-64. Единственное ограничение - оба операнда должны иметь одну и ту же разрядность.
Адресация памяти относительно счетчика команд
Данный режим заключается в использовании имени переменной или константы, которая определена в одном из разделов - .data, .data?, .const, .code и т. д.

Код (ASM):

.data

i32 dword 33

.code

main proc

mov eax, i32

ret

main endp

end

Для вычисления адреса переменных/констант применяется регистр RIP (Instruction Pointer), он же счетчик команд (Program Counter), отсюда и соответствующее название.
Косвенная адресация регистров
Косвенная адресация регистров (register-indirect addressing mode) означает, что регистр содержит адрес некоторого объекта. Используя данный адрес, извлекается данный объект. Чтобы указать, что мы хотим взять не значение из регистра, а значения из адреса, который хранится в регистре, название регистра помещается в квадратные скобки: [reg64] Где reg64 - это один из 64-разрядных регистров общего назначения: RAX, RBX, RCX, RDX, RSI, RDI, RBP, RSP, R8, R9, R10, R11, R12, R13, R14 и R15.
Инструкция lea
Для загрузки адреса некоторого объекта может применяться инструкция lea (load effective address). Данная инструкция имеет следующий синтаксис:

Код (ASM):

lea reg64, variable

Первый операнд инструкции представляет 64-разрядный регистр общего назначения, куда загружается адрес переменной variable - второго операнда. Стоит отметить, что переменная variable может представлять любой размер, поскольку в регистр загружается именно ее адрес, а адрес в 64-разрядной архитектуре имеет длину 64 бита.
Например, определим в секции данных переменную text и загрузим ее адрес в регистр rcx:

Код (ASM):

.data

text byte "hello", 0

.code

main proc

lea rcx, text ; загрузка в rcx адреса переменной text

ret

main endp

end

Стоит отметить, что в C/C++ это было бы аналогично следующему коду:

Код (ASM):

char text[] = "hello";

char *RCX = &text[0];

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

Код (ASM):

.data

i32 dword 39

.code

main proc

lea rcx, i32 ; загружаем в RCX адрес переменной i32

mov eax, [rcx] ; загружаем в EAX значение по адресу из RCX

ret

main endp

end

Здесь в регистр RCX загружается адрес переменной i32. Затем в регистр EAX помещается значение, которое хранится по адресу из регистра RCX - то есть значение переменной i32.
Также можно наоборот - сохранять значение по определенному адресу. Например:

Код (ASM):

.data

i32 dword ?

.code

main proc

lea rcx, i32 ; загружаем в регистр RCX адрес переменной i32

mov rdx, 12 ; в регистр RDX помещаем число 12

mov [rcx], rdx ; в память по адресу [RCX] помещаем значение из RDX

mov eax, i32 ; в регистр EAX помещаем значение переменной i32 - 12

ret

main endp

end

Здесь в секции данных определена неинициализированная переменная i32. Сохраним в эту переменную число 12. Для этого загружаем адрес этой переменной в регистр RCX

Код (ASM):

lea rcx, i32

Сохраняемое число помещаем вначале в регистр RDX

Код (ASM):

mov rdx, 12

Далее помещаем данные из регистра RDX в участок памяти, адрес которой хранится в регистре RCX, то есть по сути адрес переменной i32:

Код (ASM):

mov [rcx], rdx

Стоит отметить, что ассемблер не позволяет напрямую сохранить по адресу числовую константу, поэтому надо сначала числовую константу поместить в регистр, и затем сохранить значение этого регистра по адресу переменной.
Установка смещения
Дополнительно для адреса можно установить смещение в байтах. В качестве смещения выступает 32-разрядное число со знаком

Код (ASM):

[reg64 ±смещение]

Например:

Код (ASM):

.data

n1 dword 1

n2 dword 3

.code

main proc

lea rbx, n1 ; загружаем в регистр RBX адрес переменной n1

mov eax, [rbx + 4] ; в регистр EAX загружаем данные с адреса [rbx + 4], то есть переменной n2

ret

main endp

end

Здесь в регистр RBX помещается адрес переменной n1. Эта переменная занимает 4 байта (тип dword), соответственно адрес следующей переменной - n2 равен [RBX + 4]. И если мы возьмем данные по этому адресу, то фактически мы получим значение переменной n2.
Аналогично можно сохранять данные по адресу, используя смещение

Код (ASM):

.data

n1 dword 1

n2 dword 3

.code

main proc

lea rbx, n1 ; загружаем в регистр RBX адрес переменной n1

mov rdx, 15 ; в регистр RDX помещаем число 15

mov [rbx + 4], rdx ; в память по адресу [RBX] помещаем значение из RDX

mov eax, n2 ; в регистр EAX помещаем значение переменной n2 - 15

ret

main endp

end

При этом смещение также может быть отрицательным. В этом случае адрес сдвигается на указанное число байтов назад.
Использование смещений очень удобно, когда речь идет об обращении к частям каких-то сложных данных, например, массивов.
Адресация с масштабированием
Адресация с масштабированием позволяет комбинировать два регистра плюс смещение и умножать значение индексного регистра на коэффициент масштабирования 1, 2, 4 или 8, чтобы вычислить адрес данных:

Код (ASM):

[base_reg64 + index_reg64*scale]

[base_reg64 + index_reg64*scale + offset]

[base_reg64 + index_reg64*scale - offset]

base_reg64 представляет любой 64-битный регистр общего назначения, index_reg64 представляет любой 64-битный регистр общего назначения, кроме RSP, а scale (коэффициент масштабирования) должен быть одной из констант 1, 2, 4 или 8. Дополнительно можно прибавлять или отнимать смещение.
Например, у нас есть набор некоторых данных, и нам надо в этом наборе получить какой-то определенный элемент:

Код (ASM):

.data

numbers dword 11, 12, 13, 14, 15, 16, 17, 18

.code

main proc

lea rbx, numbers ; загружаем в регистр RBX адрес переменной numbers

mov rsi, 5 ; индекс получаемого двойного слова - получаем 6 элемент

mov eax, [rbx + rsi*4] ; в регистр EAX загружаем данные с адреса [rbx + rsi*4], то есть число 16

ret

main endp

end

Здесь данные представлены набором двойных слов numbers. Каждое число в этом наборе занимает 4 байта. Допустим, мы хотим получить 6-е число. Для этого в регистр RSI помещаем индекс нужного нам элемента - число 5. То есть, чтобы получить 6-е число, нам надо пройти 5 предыдущих чисел.

Код (ASM):

mov rsi, 5

Затем загружаем в регистр EAX значение 6-го числа из numbers, то есть число 16.

Код (ASM):

mov eax, [rbx + rsi*4]

Адрес складывается из следующих компонентов. Во-первых, в регистре RBX адрес начала набора numbers, то есть адрес первого элемента из этого набора. Чтобы дойти к адресу 6-го элемента от адреса 1-го элемента, нам надо пройти 5 элементов, поэтому в регистре RSI число 5. Каждый элемент занимает 4 байта, соответственно, чтобы пройти от 1-го элемента до 6-го, нам надо пройти rsi*4 = 5 *4 = 20 байтов.
Преобразование данных
Как и в общем случае при косвенной адресации можно выполнять преобразования данных. Например, возьмем следующую программу:

Код (ASM):

.data

n1 byte 11

n2 byte 12

n3 byte 13

n4 byte 14

.code

main proc

lea rbx, n1 ; загружаем в регистр RBX адрес переменной n1

mov eax, [rbx] ; в регистр EAX загружаем данные с адреса [rbx], то есть переменной n1

ret

main endp

end

В регистр RBX помещается адрес переменной n1, затем данные из памяти по адресу из RBX помещаются в регистр EAX. То есть мы ожидаем, что в регистре EAX в итоге будет число 11 - значение переменной n1. Однако если мы скомпилируем программу с помощью MASM, запустим и проверим содержимое регистра EAX, то мы увидим, что там не число 11:

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

c:\asm>echo %ERRORLEVEL%
235736075

c:\asm>

Число 235736075 вряд ли равно значению переменной n1. Поскольку значение помещается в 32-разрядный регистр EAX, то по адресу из RBX выбирается 4 байта, то есть все последующие переменные - n2, n3 и n4. Но нам надо получить только значение переменной n1. Для этого мы можем получить значение в 8-разрядный регистр:

Код (ASM):

.data

n1 byte 11

n2 byte 12

n3 byte 13

n4 byte 14

.code

main proc

lea rbx, n1 ; загружаем в регистр RBX адрес переменной n1

mov rax, 0 ; обнуляем регистр rax

mov al, [rbx] ; AL = 11 (и EAX = 11)

ret

main endp

end

Либо мы можем применить преобразование до байта:

Код (ASM):

.data

n1 byte 11

n2 byte 12

n3 byte 13

n4 byte 14

.code

main proc

lea rbx, n1

movzx eax, byte ptr[rbx]

ret

main endp

end

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

Mikl___ · 29 окт 2026 в 14:00

Работа с данными и памятью
Выравнивание
Для ускорения доступа объектам в памяти в архитектуре x86-64 может применяться выравнивание. Выравнивание данных не всегда необходимо, так как кэш-архитектура современных процессоров x86-64 на самом деле обрабатывает большинство невыровненных данных. Тем не менее иногда доступ к данным, которые не выровнены по соответствующему адресу, может потребовать дополнительного времени. И если скорость доступа к подобным данным критична, то можно использовать выравнивание.
Выравнивание означает, что адрес объекта является четным и кратен определенному размеру. В качестве такого размера обычно выбирают размер объекта, если он не более 32 байт и является степенью двойки. Для объектов размером более 32 байт обычно достаточно выравнивание объекта по 8-, 16- или 32-байтовой адресной границе. Для установки выравнивания применяется директива align

Код (ASM):

align выравнивание

В качестве операнда директиве передается целочисленное значение: 1, 2, 4, 8 или 16. Как правило, если нужен максимально быстрый доступ, то необходимо выбирать значение, равное размеру объекта, по которому надо выровнять. То есть для выравнивания по слову (16 бит) применяется выражение align 2, для выравнивания по двойному слову (4 байта) применяется выражение align 4, по четверным словам - align 8 и т.д. Если размер объекта не является степенью числа 2, то обычно для выравнивания используется первая ближайщая степень числа 2 (максимум до 16 байт), большее размера объекта. При этом объекты real80 (и tbyte) выравниваются только по 8 байтам. Например:

Код (ASM):

.data

d1 dword 33

w1 word 22

b1 byte 11

align 2

w2 word 10

Если MASM встречает директиву align в разделе .data, он выравняет последующую переменную по адресу, который кратен указанному выравниванию. Если MASM определяет, что текущий адрес директивы align не является целым числом, кратным указанному значению, то после предыдущей переменной добавляются дополнительные байты до тех пор, пока текущий адрес в разделе .data не станет кратен указанному значению.
Первое объявление .data в программе (на Windows) размещает свои переменные по адресу, который кратен 4096 байтам. Какая бы переменная ни появилась первой в этом объявлении .data, она гарантированно будет выровнена. Каждая последующая переменная размещается по адресу, который представляет собой сумму размеров всех предыдущих переменных плюс начальный адрес этой секции .data.
Например:

Код (ASM):

.data

d1 dword 33

w1 word 22

b1 byte 11

align 2

w2 word 10

.code

main proc

mov rax, 0

mov ax, [w2 - 4] ; смещаемся назад на 4 байта - [w2-4] = [w1]

ret

main endp

end

Здесь первые три переменных в сумме занимают 7 байт (4 + 2 + 1):

Код (ASM):

d1 dword 33

w1 word 22

b1 byte 11

Но за ними идет еще одна переменная с выравниванием по 2 байтам:

Код (ASM):

align 2

w2 word 10

Поэтому после переменной b1 добавляется еще один байт, чтобы последующая переменная w2 располагалась по четному адресу, который кратен 2. Соотвественно, чтобы перейти от адреса переменной w2 к адресу переменной w1, надо вычесть 4 байта (размер переменной w1 + размер переменной b1 + 1 байт для установки выравнивания). И в данном случае в регистре AX окажется значение переменной w1.

Код (ASM):

mov ax, [w2 - 2] ; [w2-2] = [b1]

Без выравнивания для перехода от адреса переменной w2 к адресу переменной w1 потребовалось бы смещение назад на 3 байта:

Код (ASM):

.data

d1 word 33

w1 word 22

b1 byte 11

w2 word 10 ; переменная w2 не выравнена

.code

main proc

mov rax, 0

mov ax, [w2-3] ; смещаемся назад на 3 байта

ret

main endp

end

Выравнивание делает программу немного больше (на несколько байтов), однако в обмен получаем более быстрый доступ к данным. Учитывая, что программа увеличится всего на несколько байтов, то это может быть неплохим решением.

Mikl___ · 29 окт 2026 в 14:52

Работа с данными и памятью
Стек
Стек — это динамическая структура данных, которая хранит важную информация о программе, включая локальные переменные, информацию о подпрограммах и временные данные. В архитектуре x86-64 стек реализуется с помощью сегмента стека. Процессор x86-64 управляет стеком через регистр RSP (указатель стека). Когда программа начинает выполняться, операционная система инициализирует регистр RSP адресом последней ячейки памяти в сегменте стека. В процессе работы программы данные записываются в сегмент стека или, наоборот, извлекаются из стека.
Стек растет от больших адресов к меньшим, то есть при добавлении в стек данных, адрес добавляемых данных будет уменьшаться. При запуске программы обычно стек выровнен по 8-байтовой границе. Например, RSP может хранить адрес 0x0000009BA9EFF9A8 (адрес оканчивается на 8).
Для добавления данных в стек применяется инструкция push, которая имеет следующий синтаксис:

Код (ASM):

push reg16

push reg64

push mem16

push mem64

pushw constant16

push constant32 ; расширяется до 64 бит

Итак, мы можем добавить в стек значения 16- и 64-разрядного регистра, 16- и 64-разрядной переменной и 16- и 32-разрядной константы (32-битная констранта расширяется до 64 бит).
При выполнении инструкции push от значения регистра RSP вычитается размер операнда. А по адресу, который хранится в стеке, помещается значение операнда.

Код (ASM):

RSP = RSP - размер операнда

[RSP] = значение операнда

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

Код (ASM):

pop reg16

pop reg64

pop memory16

pop memory64

Инструкция в качестве операнда получает место, куда надо сохранить данные из стека. Это может быть или 16- и 64-разрядный регистр, или 16- и 64-разрядная переменная. При выполнении этой инструкции в операнд помещается значение, которое хранится в адресе из RSP. А само значение RSP увеличивается на размер операнда:

Код (ASM):

operand = [RSP]

RSP = RSP + размер операнда

Например, возьмем следующую программу:

Код (ASM):

.code

main proc

mov rdx, 15

push rdx ; в конец стека помещаем содержимое регистра RDX

pop rax ; значение из конца стека помещаем в регистр RAX

ret

main endp

end

Допустим, регистр RSP содержит изначально адрес 00FF_FFF8h.

Пусть в регистре RDX хранится некоторое значение, которое с помощи инструкции push заталкивается в стек:

Код (ASM):

push rdx

В результате в последующие 8 байт начиная с адреса, который хранится в RSP, помещается значение из регистра RDX (в данном случае число 15). А в регистр RSP будет помещен адрес RSP-8, то есть условно 00FF_FFF0h и сохранит текущее значение регистра RDX в ячейках памяти начиная с 00FF_FFF0h по 00FF_FFF7h, то есть займет 8 байт.

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

Код (ASM):

pop rax

В результате в RAX помещается число из стека (в данном случае число 15). А в регистр RSP будет помещен адрес RSP+8, то есть условно 00FF_FFF0h.

Принцип LIFO и сохранение регистров в стек
Наиболее распространенное использование команд push и pop — это сохранение значений регистров во время промежуточных вычислений. Поскольку регистры — лучшее место для хранения временных значений, и регистры также могут потребоваться для других операций, поэтому в процессе программы легко исчерпать регистры. Инструкции push и pop позволяют сохранить начальные значения регистров при старте программы, а при завершении программы восстановить эти значения.
Следует учитывать, что стек представляет структуру LIFO (Last In, First Out или Последний вошел, первый вышел), что значит, что получение данных из стека происходит в порядке, обратном их добавлению. Рассмотрим следующую программу:

Код (ASM):

.code

main proc

mov rax, 11

mov rdx, 33

push rax

push rdx

pop rax

pop rdx

ret

main endp

end

Допустим, в самом начале программы до добавления данных стек регистр RSP хранит адрес 00FF_FFF8.

Затем добавляем в стек значение регистра RAX:

Код (ASM):

push rax

Адрес в RSP смещается на 8 байтов и указывает на адрес значения из регистра RAX

Далее добавляем в стек значение регистра RDX:

Код (ASM):

push rdx

Адрес в RSP смещается на 8 байтов и указывает на адрес значения из регистра RDX

После добавления мы последовательно извлекаем данные. Первая инструкция извлекает данные, на которые указывает регистр RSP, в регистр RAX:

Код (ASM):

pop rax

Однако поскольку RSP перед операцией извлечения указывал на адрес последнего добавленного значения - значения регистра RDX, то регистр RAX получит значение регистра RDX. Соответственно при последующей инструкции pop:

Код (ASM):

pop rdx

Регистр RDX получить значение регистра RAX, которое было в регистре RAX до добавления в стек.
Поэтому если мы хотим восстановить начальные значения регистров, то нам надо извлекать значения в порядке, обратном добавлению

Код (ASM):

push rax

push rdx

pop rdx ; Последним добавлено значение RDX, поэтому сначала извлекаем в RDX

pop rax

В любом случае стоит помнить, что количество инструкций push и pop должно быть равно, сколько раз мы добавили данные в стек, столько раз мы должны получить данные из стека.
Сохранение флагов состояния
Ассемблер предоставляет дополнительную пару инструкций pushfq и popfq для сохранения и восстановления соответственно регистра RFLAGS (и всех флагов состояния). Например:

Код (ASM):

.code

main proc

pushfq ; сохраняем значения флагов

mov al, 255

add al, 2 ; 255 + 2 = 257 - флаг CF будет установлен

popfq ; восстанавливаем значения флагов

jc set ; если флаг CF установлен, переход к метке set

mov rax, 0

ret

set:

mov rax, 1

ret

main endp

end

Здесь инструкцией pushfq сначала сохраняем флаги. По умолчанию флаг переноса CF будет равен 0.
Затем выполняем сложение 255 + 2, что даст 257 и что очевидно за пределы разрядности регистра AL, соответственно будет установлен флаг переноса CF. Далее с помощью инструкции jc set переходим к метке set, если флаг CF установлен. Однако перед этой инструкцией мы восстанавливаем флаги - popfq. То есть флаг CF получит свое значение 0, и никакого перехода к метке set не произойдет.
Восстановление стека без извлечения данных
При завершении программы следует восстановить адрес в RSP. Как выше было показано, для этого мы можем использовать инструкцию pop. Однако может сложиться ситуация, что данные не требуется извлекать из стека. Например, в зависимости от некоторых условий данные могут понадобиться, а могут не понадобиться. Если данные не нужны, извлекать каждые 8 байт отдельно с помощью инструкции pop не имеет смысла, особенно если надо извлечь много данных из стека. И в этом случае мы можем восстановить адрес в RSP, просто прибавив нужное значение - смещение относительно начального адреса. Например:

Код (ASM):

.code

main proc

mov rax, 2

mov rdx, 3

push rax

push rdx

add rsp, 16 ; прибавляем к адресу в RSP 16 байт

ret

main endp

end

Здесь в стек помещаем значения двух регистров - RAX и RDX, то есть адрес в RSP уменьшится на 16 байт (совокупный размер двух регистров). И чтобы быстро восстановить стек, прибавляем к адресу в RSP 16 байт:

Код (ASM):

add rsp, 16

Подобным образом можно вычитать из адреса в RSP определенное число, тем самым резервируя в стеке некоторое пространство:

Код (ASM):

.code

main proc

sub rsp, 16 ; смещаем адрес в RSP на 16 байт

mov rax, 2

add rsp, 16 ; восстанавливаем адрес в RSP

ret

main endp

end

Вычитание определенного количество байтов из стека может потребоваться при взаимодействии с некоторыми внешними функциями, например, на языках C/С++ для резервирования места для параметров функций или для выравнивания стека. Так, до вызова функций в Windows в соответствии с Microsoft ABI стек должен быть выровнен по 16-байтовой границе. При использовании инструкции push для сохранения значения регистра перед вызовом внешней функции надо убедиться, адрес RSP кратен 16 байтам.
Косвенная адресация в стеке
Как и в случае с любым другим регистром, в отношении регистра стека RSP можно использовать косвенную адресацию и обращаться к данным в стеке без смещения указателя RSP. Например:

Код (ASM):

.code

main proc

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

mov rdx, 11

mov [rsp], rdx ; помещаем в стек значение регистра RDX

mov rax, [rsp] ; в RAX помещаем значение по адресу из RSP - число 11

add rsp, 16 ; восстанавливаем указатель стека

ret

main endp

end

В данном случае в стек помещаем число из регистра RDX - число 11.

Код (ASM):

mov [rsp], rdx

Подобную форму размещения данных в стеке можно рассматривать как альтернативу инструкции push, если нам не надо изменять значение указателя стека RSP. То есть мы можем сохранить таким образом данные по адресу в RSP, но после этого RSP продолжает хранить тот же адрес.
Далее в регистр RAX помещаем значение, которое располагается по адресу из RSP. Фактически это тот адрес, где располагается число 11.

Код (ASM):

mov rax, [rsp]

Аналогично можно применять смещения и масштабирование. Например:

Код (ASM):

.code

main proc

push 12

push 13

push 14

mov rax, [rsp + 8] ; [rsp + 8] - адрес значения 13

; извлекаем сохраненные значения в r8, r9, r10

pop r8

pop r9

pop r10

ret

main endp

end

Здесь в стек последовательно помещаются три числа 12, 13, 14. Каждое число будет занимать 8 байт. После добавления адрес в RSP будет указывать на адрес последнего добавленного числа - 14. И чтобы, например, получить предыдущее число - 13, нам надо к адресу в RSP прибавить 8. И в данном случае получаем это число в регистр RAX.

Код (ASM):

mov rax, [rsp + 8]

Соотвественно чтобы получить из стека первое число - 12, надо к адресу в RSP прибавить 16:

Код (ASM):

mov rax, [rsp + 16]

Другой пример:

Код (ASM):

.code

main proc

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

mov rbx, 12

mov rdx, 13

mov [rsp], rbx ; помещаем значение из RBX по адресу RSP

mov [rsp+8], rdx ; помещаем значение из RDX по адресу RSP+8

mov rax, [rsp] ; в RAX помещаем значение по адресу из RSP

add rax, [rsp+8] ; складываем с числом из RSP+8

add rsp, 16 ; восстанавливаем данные из стека

ret

main endp

end

Здесь по адресу RSP располагается значение региста RBX, а по адресу RSP+8 - регистра RDX. В RAX извлекаем значение по адресу RSP (12), и затем складываем его со значением из RSP+8 (13). Таким образом, в RAX будет число 25.
Ограничения места в стеке
По умолчанию данные в стеке занимают то место, которое соответствует размеру регистра. Так, инструкция mov [rsp], rbx помещала в стек 8 байт из RBX. То есть данные в стеке занимали 8 байт. Однако в примере выше в RBX хранится число, для которого достаточно и 1 байта, для него не требуется аж 8 байт. Пространство в стеке расходуется не экономично. В этом случае с помощью преобразования данных мы можем явным образом указать, сколько байтов мы хотим использовать в стеке

Код (ASM):

.code

main proc

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

mov rbx, 11

mov rdx, 12

mov [rsp], bl ; помещаем байт из BL по адресу RSP

mov [rsp+1], dl ; помещаем байт из DL по адресу RSP+1

movzx rax, byte ptr [rsp] ; в AL помещаем значение по адресу из RSP

add al, byte ptr [rsp+1] ; складываем с числом из RSP+1

add rsp, 16 ; восстанавливаем данные из стека

ret

main endp

end

Здесь в RAX извлекаем только один байт:

Код (ASM):

movzx rax, byte ptr [rsp]

Затем добавляем в AL еще один байт из стека, который хранится по адресу RSP+1:

Код (ASM):

add al, byte ptr [rsp+1]

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

Код (ASM):

.code

main proc

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

mov qword ptr [rsp], 11 ; в стек помещаем число 11 - оно занимает 8 байт

mov word ptr [rsp+8], 15 ; по адресу в RSP+8 помещаем 2-байтное число 15

mov rax, qword ptr [rsp] ; RAX = 11

add ax, word ptr [rsp+8] ; складываем с числом из RSP+8

add rsp, 16 ; восстанавливаем данные из стека

ret

main endp

end

Здесь сначала помещаем в стек число 11, которое будет занисать 8 байт, так как мы приводим к типу qword:

Код (ASM):

mov qword ptr [rsp], 11

Затем по адресу RSP+2 помещаем число 15, которое будет занимать 2 байта:

Код (ASM):

mov word ptr [rsp+8], 15

Затем извлекаем эти данные и складываем их:

Код (ASM):

mov rax, qword ptr [rsp] ; RAX = 11

add ax, word ptr [rsp+8] ; складываем с числом из RSP+8

Стоит обратить внимание, что тип извлекаемых данных соответствует размеру регистра, либо при извлечение 1 байта применется операция расширения movzx/movsx. Некорректное извлечение может привести к некорректным результатам:

Код (ASM):

.code

main proc

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

mov byte ptr [rsp], 10 ; по адресу в RSP помещаем число 10

mov byte ptr [rsp+1], 11 ; по адресу в RSP+1 помещаем число 11

mov rax, [rsp] ; RAX = ?

add rsp, 16 ; восстанавливаем данные из стека

ret

main endp

end

Здесь в стек последовательно помещаем два байта - числа 10 и 11. Затем извлекам из стека данные. Но обратите внимание как идет извлечение

Код (ASM):

mov rax, [rsp] ; RAX = ?

Какое число окажется в регистре RAX? Здесь в регистр RAX из стека скопируются 8 байт, из которых первые два байта - это числа 10 и 11, остальные 6 байт неопределены. Соответственно результат в RAX неопределен. И чтобы взять только нужную нам порцию данных, следует использовать преобразование типов:

Код (ASM):

.code

main proc

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

mov byte ptr [rsp], 10 ; по адресу в RSP помещаем число 10

mov byte ptr [rsp+1], 11 ; по адресу в RSP+1 помещаем число 11

movzx rax, byte ptr [rsp] ; RAX = 10

add rsp, 16 ; восстанавливаем данные из стека

ret

main endp

end

Расположение данных в стеке
Может возникнуть вопрос, как числа размером более одного байта сохраняются в стеке? Рассмотрим следующую программу:

Код (ASM):

.code

main proc

mov rdx, 0102030405060708h ; в RDX 8-байтное число

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

movzx rax, byte ptr [rsp] ; в RAX сохраняем 1 байт по адресу в RSP

pop rdx ; извлекаем число из стека в RDX

ret

main endp

end

Здесь в регистр RDX сохраняем 16-ричное число 0x0102030405060708. Далее это число помещаем в стек.
Затем с помощью инструкции movzx помещаем в RAX 1 байт, извлеченный из стека по адресу который хранится в RSP. Чему будет равен этот байт - 0, 1 или 8?
При добавлении в стек старшие биты числа располагаются по старшим адресам, а младшие биты по младшим адресам:

Соответственно в регистре RAX окажется число 0х08
Аналогично, если мы хотим получить старший байт 8-битного числа, то мы можем сместиться относительно адреса RSP вниз на 7 байт (то есть RSP+7):

Код (ASM):

movzx rax, byte ptr [rsp+7] ; RAX = 0x01

Mikl___ · 29 окт 2026 в 14:59

Работа с данными и памятью
Указатели
Ассемблер позволяет определять указатели - переменные, которые хранят адрес других объектов. Для получения адреса объекта применяется выражение

Код (ASM):

offset переменная

Поскольку адрес в архитектуре x86-64 занимает 8 байт, то для хранения адреса нам надо определить переменную с типом qword. Например, определим переменную и получим ее адрес:

Код (ASM):

.data

n dword 22

pn qword ?

.code

main proc

; установка указателя

mov rax, offset n ; загружаем адрес переменной n

mov pn, rax ; сохраняем адрес в переменную pn

; получение данных по указателю

mov rbx, pn ; в rbx помещаем адрес из переменной pn

mov rax, [rbx] ; обращаемся по адресу из rbx

ret

main endp

end

Здесь определена переменная-указатель pn, которая представляет тип qword и которая будет хранить адрес переменной n. Сначала получаем адрес в регистр RAX и затем передаем его в указатель pn:

Код (ASM):

mov rax, offset n

mov pn, rax

Если нам надо использовать значение по указателю, можно сначала поместить значение указателя в регистр, а затем использовать косвенную адресацию для получения самого значения по указателю.

Код (ASM):

mov rbx, pn ; в rbx помещаем адрес из переменной p

mov rax, [rbx] ; обращаемся по адресу из rbx

В итоге в регистре RAX окажется число 22 - значение переменной n.
При этом мы можем получить адрес уже при определении переменной-указателя:

Код (ASM):

.data

n dword 11

pn qword offset n ; получаем адрес переменной n

.code

main proc

; получение данных по указателю

mov rbx, pn ; в rbx помещаем адрес из переменной pn

mov rax, [rbx] ; в RAX число 11

ret

main endp

end

Указатель необязательно должен представлять переменную - это может быть и константа:

Код (ASM):

pn equ offset n ; константа pn указывает на переменную n

.data

n dword 12

.code

main proc

; получение данных по указателю

mov rbx, pn ; в rbx помещаем адрес из переменной pn

mov rax, [rbx] ; в RAX число 11

ret

main endp

end

Операции с адресом
При получении адреса мы можем использовать ряд операций:

Код (ASM):

offset переменная [смещение]

offset переменная + смещение

offset переменная - смещение

В этом случае мы можем получить адрес, который смещен относительно адреса переменной на несколько байтов вперед или назад. Выражение переменная [смещение] фактически эквивалентно выражению переменная + смещение. Например:

Код (ASM):

.data

nums dword 11, 12, 13, 14, 15, 16

p qword ?

.code

main proc

; установка указателя

mov rax, offset nums + 4 ; загружаем адрес переменной nums + 4

mov p, rax ; сохраняем адрес в переменную p

; получение данных по указателю

mov rbx, p ; в rbx помещаем адрес из переменной p

mov rax, [rbx] ; обращаемся по адресу из rbx

ret

main endp

end

Здесь переменная nums представляет набор 32-битных чисел. Выражение offset nums возвращает адрес перемнной num - адрес первого числа из этого набора. Соответственно чтобы получить адрес второго числа из этого набора, нам надо прибавить размер одного элемента в байтах, то есть 4 байта - offset nums + 4

Mikl___ · 29 окт 2026 в 15:05

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

Код (ASM):

.data

text byte "Hello"

.code

main proc

mov al, text ; в регистре AL числовой код символа H - 72

ret

main endp

end

Здесь переменная text представляет набор из пяти байтов. Если мы поместим переменную, которая представляет набор байт, в регистр, то он будет содержать код первого байта.
Также можно через запятую перечислять числовые коды символов, которые входят в строку:

Код (ASM):

.data

text byte 72, 101, 108, 108, 111

.code

main proc

xor rax, rax

mov al, text ; в регистре AL числовой код символа H

ret

main endp

end

Строки с нулевым байтом
Распространенным типом строк являются строки, которые оканчиваются на нулевой байт. Что может быть очень удобно при операциях со строками, поскольку мы знаем где у нее завершение. И, например, при взаимодействии с кодом C/C++ обычно требуется, чтобы строки завершались нулевым байтом - признаком завершения строки. В этом случае при определении строк в ассемблере можно в конце строки дописать числовой код символа:

Код (ASM):

.data

text byte "Hello", 0

Здесь к строке Hello добавляется нулевой байт.
Используем нулевой байт для подсчета количества символов в строке:

Код (ASM):

.data

text byte "Hello", 0

.code

main proc

lea rbx, text

xor rax, rax ; в регистре RAX по умолчанию 0

startWhile:

cmp byte ptr [rbx+rax*1], 0 ; сравниваем значение по адресу [rbx+rax*1] c 0

je endWhile ; если дошли до нулевого байта, выходим из цикла

inc rax ; увеличиваем счетчик на 1

jmp startWhile ; переходим обратно к startWhile

endWhile:

ret

main endp

end

В данном случае регистр RAX выступает в качестве счетчика - он хранит количество символов и по умолчанию равен 0.
В регистр RBX загружаем адрес строки text. На метку startWhile проецируем начило цикла, в котором будем подсчитывать количество символов. Для подсчета с помощью инструкции cmp сравниваем значение по адресу [rbx+rax*1] с нулевым байтом.

Код (ASM):

cmp byte ptr [rbx+rax*1], 0

В начале программы, поскольку RAX равен 0, то выражение [rbx+rax*1] даст нам адрес первого символа в строке text. Если символ равен нулевому байту, то переходим к метке endWhile, то есть фактически выходим из цикла

Код (ASM):

je endWhile

Если же символ по адресу [rbx+rax*1] не нулевой байт, то увеличиваем значение в регистре RAX на 1 и переходим опять к метке startWhile. И таким образом, сравниваем следующий символ строки text с нулевым байтом.
С одной строны, это удобно, мы всегда знаем, где у строки конец, и можем определить строку из произвольного количества символов. В то же время в каких=то ситуациях это может быть не оптимальный способ представления строки. Например, опять же, чтобы узнать количество символов, нам надо перебрать всю строку.
Строки с фиксированным количеством символов
В строках с фиксированным количеством символов обычно первый символ указывает на количество символов:

Код (ASM):

.data

text byte 5, "Hello"

.code

main proc

lea rbx, text

movzx rax, byte ptr [rbx] ; в регистре RAX - 5

ret

main endp

end

Однако в этом случае мы ограничены строками длиной 255 байт (из которых первый байт - длина строки). Также можно автоматически вычислять длину с помощью констант:

Код (ASM):

.data

text byte textLength, "Hello World"

textLength = $-text-1

.code

main proc

lea rbx, text

mov rax, textLength ; в регистре RAX - 11

ret

main endp

end

Mikl___ · 29 окт 2026 в 15:13

Работа с данными и памятью
Сортировка массива
Рассмотрим сортировку массива:

Код (ASM):

.data

; массив для сортировки:

numbers dword 2, 1, 14, 11

dword 5, 9, 4, 10

dword 6, 8, 16, 12

dword 7, 3, 15, 13

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

numbersLength = ($ - numbers) / elemSize ; число элементов

swap byte ? ; swap - индикатор, был ли на предыдущей итерации обмен значениями

.code

; Параметры

; в RCX - адрес массива

; в RDX - количество элементов

sort proc

dec rdx ; нам надо пройти на 1 цикл меньше, поэтому уменьшаем на 1

; внешний цикл:

outer:

mov swap, 0

xor rbx, rbx ; RBX = 0 - счетчик проверенных элементов

inner:

cmp rbx, rdx ; пока не сравним все элементы, то есть RBX < RDX

jnb innerEnd

mov eax, [rcx + rbx*elemSize] ; EAX = numbers[RBX]

cmp eax, [rcx + rbx*elemSize + elemSize] ; сравниваем, большем ли число из EAX, чем numbers[RBX + 1]

jna withoutSwap ; если EAX не больше, то переходим к метке withoutSwap

; если же numbers[RBX] > numbers[RBX + 1], то обмениваем значениями

mov r8d, [rcx + rbx*elemSize + elemSize]

mov [rcx + rbx*elemSize + elemSize], eax

mov [rcx + rbx*elemSize], r8d

mov swap, 1 ; устанавливаем, что был совершен обмен

withoutSwap:

inc rbx ; увеличиваем счетчик элементов

jmp inner ; переход для сравнения новой пары элементов

; Если был совершен обмен, то переходим обратно к outer

innerEnd:

cmp swap, 1

je outer

ret

sort endp

main proc

lea rcx, numbers

mov rdx, numbersLength ; 16 элементов в массиве

call sort

; для примера получим последний элемент

lea rbx, numbers

mov eax, [rbx + (numbersLength-1) * elemSize ]

ret

main endp

end

В секции данных определен массив numbers, который будет сортировать, а также длина массива в элементах - numbersLength, размер одного элемента - elemSize и переменная swap - индикатор обмена значениями между элементами. При сравнении если предыдущий элемент больше следующего, мы меняем их местами. Чтобы указать, что обмен был, переменной swap будет присваиваться значение 1. Если обмена не было, то есть предыдущий элемент оказался меньше последующего, то swap будет равно 0.
Затем идет определение функции sort, которая сортирует массив. Предполагается, что адрес массива будет передаваться через регистр RCX, а количество элементов в массиве - через RDX. Поскольку при сортировке пузырьком нам надо провести numbersLength-1 сравнений, то уменьшаем значение RDX на единицу:

Код (ASM):

dec rdx

На метку outer проецируется внешний цикл. В нем у переменной swap устанавливаем значение 0:

Код (ASM):

mov swap, 0

И обнуляем регистр RBX, который будет выступать в качестве счетчика сравнений:

Код (ASM):

xor rbx, rbx

Дальше идет условный внутренний цикл, который проецируется на метку inner. В нем мы сравниваем значения RBX и RDX - количество проведенных сравнений и максимальное количество сравнений.

Код (ASM):

cmp rbx, rdx

jnb innerEnd

Если значение RBX равно значению RDX, значит все сравнения проведены, и переходим к метке innerEnd.
Если же не все значения сравнены, то в регистр EAX помещаем первый элемент для сравнения (по адресу [rcx + rbx*elemSize] ) и сравниваем его со следующим элементом (по адресу [rcx + rbx*elemSize + elemSize])

Код (ASM):

mov eax, [rcx + rbx*elemSize]

cmp eax, [rcx + rbx*elemSize + elemSize]

Если первый элемент оказался меньше, то переходим к метке withoutSwap:

Код (ASM):

jna withoutSwap

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

Код (ASM):

mov r8d, [rcx + rbx*elemSize + elemSize]

mov [rcx + rbx*elemSize + elemSize], eax

mov [rcx + rbx*elemSize], r8d

mov swap, 1

После обмена переменная swap получает значение 1.
Далее на метке withoutSwap увеличиваем счетчик сравнений и переходим обратно к метке inner, пока не сравним все элементы.

Код (ASM):

withoutSwap:

inc rbx

jmp inner

Если сравнены все элементы, срабатывает код после метки innerEnd:

Код (ASM):

innerEnd:

cmp swap, 1

je outer

Если сравнены все элементы, но произошел обмен, и соответственно переменная swap равна 1, то значит, что еще может потребоваться обмен значений. Поэтому, если swap равна 1, то переходим обратно к метке outer и повторно сравниваем все элементы друг с другом.
Если же swap равна 0, то есть при сравнениях не было не одного обмена, а это значит, что массив уже отсортирован, то выходим из функции.
В процедуре main вызываем процедуру sort, передавая в регистры RCX и RDX адрес массива и количество элементов:

Код (ASM):

lea rcx, numbers

mov rdx, numbersLength

call sort

Mikl___ · 29 окт 2026 в 16:13

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

Код (ASM):

numbers dword 1, 2, 3, 4

dword 5, 6, 7, 8

dword 9, 10, 11, 12

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

Код (ASM):

numbers dword 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

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

Код (ASM):

element_address = base_address + (row_index * col_size + col_index) *element_size

Где base_address - адрес начала массива (его первого элемента), row_index - номер строки элемента, col_size - количество столбцов/элементов в строке, col_index - номер столбца элемента, а element_size - размер элементов в байтах. Нумерация строк и столбцов начинается с нуля, то есть номер первой строки или первого столбца - 0.
Например, возьмем выше определенный двухмерных массив numbers. Предположим, нам надо получить элемент в 2-й строке и 3-столбце (число 7). Тогда расчет адреса элемента будет выглядеть следующим образом:

Код (ASM):

element_address = адрес_numbers + (1 * 4 + 2) *4

То есть мы получим, что для получения адреса числа 7 нам надо к адресу массива numbers прибавить (1 * 4 + 2) *4 = 6 * 4 = 24 байт. Посмотрим, как это будет выглядеть в программе на ассемблере:

Код (ASM):

.data

numbers dword 1, 2, 3, 4

dword 5, 6, 7, 8

dword 9, 10, 11, 12

elemSize = 4 ; размер одного элемента - dword

rows = 3 ; кол-во строк

cols = 4 ; кол-во столбцов

rowIndex dword 1 ; обращаемся к 2-й строке

colIndex dword 2 ; обращаемся к 3-му столбцу

; Нам надо получить [rbx + (cols * rowIndex + colIndex) * elemSize]

.code

main proc

lea rbx, numbers ; в RBX - адрес массива numbers

xor rdx, rdx

mov edx, rowIndex ; в RDX индекс строки - rowIndex

imul edx, cols ; cols * rowIndex

add edx, colIndex ; cols * rowIndex + colIndex

mov eax, [rbx + rdx * elemSize] ; EAX = 7

ret

main endp

end

В регистр RBX помещаем адрес массива numbers. Это будет базовый адрес, относительно которого будут идти все расчеты

Код (ASM):

lea rbx, numbers

Для вычисления эффективного адреса сначала в регистр EDX помещаем индекс строки элемента - переменную rowIndex

Код (ASM):

mov edx, rowIndex

Затем умножаем индекс строки на количество столбцов

Код (ASM):

imul edx, cols

Затем прибавляем к значению в EDX индекс столбца нужного элемента:

Код (ASM):

add edx, colIndex

Таким образом мы получили индекс элемента внутри массива numbers. Далее мы можем умножить этот индекс на размер элементов и прибавить к базовому адресу - адресу первого элемента в numbers. И таким образом получим адрес числа 7:

Код (ASM):

mov eax, [rbx + rdx * elemSize]

Опеределение массива
Стоит отметить, что если нам надо определить неинициализированный многомерный массив или многомерный массив, где все элементы имеют какое-то одно начальное значение, то мы можем использовать оператор dup:

Код (ASM):

numbers dword 3*4 dup (1)

Здесь определяется массив numbers из 12 элементов, каждый из которых равен 1.
MASM позволяет использовать вложенные выражения dup. Так, вместо предыдущего определения массива мы могли бы написать так:

Код (ASM):

numbers dword 3 dup (4 dup(1))

Можно прочитать эту запись так: определяем набор из 3 элементов, где каждый вложенный элемент представляет набор из 4 чисел dword. То есть по сути 3 строки, каждая из которых содержит 4 столбца.

Mikl___ · 29 окт 2026 в 16:18

Работа с данными и памятью
xlat и поиск в таблицах
Таблицы представляют некоторые наборы неизменяемых данных. В ряде ситуаций таблицы позволяют ускорить выполнение программы, хотя за хранение самой таблицы придется пожертвовать небольшим количеством дополнительной памяти. А архитектура x86-64 предоставляет специальную инструкцию xlat для упрощения поиска в таблицах.
Например, возьмем программу, которая переводит символ из нижнего регистра в верхний:

Код (ASM):

.data

character byte "b"

.code

main proc

xor rax, rax

mov al, character

cmp al, 'a'

jb notLower

cmp al, 'z'

ja notLower

and al, 5fh ; преобразуем код символа в верхний регистр

mov character, al

notLower:

; остальная часть программы

ret

main endp

end

В регистр AL передается код символа из переменной AL. Далее проверяем код символа - соответствует ли он диапазону для букв в нижнем регистре. Если соответствует, с помощью операции AND применяем маску 5fh, которая убирает 6-бит и тем самым преобразует символ в верхний регистр. Однако если символ изначально представляет букву в верхнем регистре или представляет не букву, а цифру или что-то еще, то переходим к метке notLower
Таблицы позволяют сократить код программы:

Код (ASM):

.data

table byte 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32

byte 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64

byte 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96

byte 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90

character byte "b"

.code

main proc

xor rax, rax

mov al, character

lea rbx, table

xlat

mov character, al

; остальная часть программы

ret

main endp

end

Здесь таблица представлена переменной table, которая хранит коды символов ASCII. Причем, начиная с 97 байта по 123 размещены коды символов ASCII в верхнем регистре, на которые будут заменяться символы в нижнем регистре. Эти коды символов в верхнем регистре располагаются по индексам соответствующих им символов в нижнем регистре. Например, буква "a" имеет код 97. По индексу 97 в таблице располагается код символа "A" - число 65.
Для замены символов применяется инструкция xlat, которая фактически аналогична инструкции

Код (ASM):

mov al, [rbx + al * 1]

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

Mikl___ · 29 окт 2026 в 16:35

Работа с данными и памятью
Структуры
Ассемблер MASM позволяет определять структуры - составные типы данных, которые состоят из элементарных типов. Для определения структуры применяется слово struct:
название_структуры struct
поля структуры
название_структуры ends
Сначала идет название структуры, затем слово struct. Далее идут переменные структуры (еще назваются полями) - те элементы, из которых состоит структуры. Завершается определение структуры также названием структуры, за которым следует слово end. Например:
point struct ; структура представляет точку
x word ? ; координата Х
y word ? ; координата Y
point ends
Здесь определена структура point, которая условно представляет точку. В этой структуре определено два поля. Поля определяются также как и обычные переменные. Первая переменная представляет координату X, а вторая переменная - координату Y. Обе переменных представляют тип word.
Структура можно определяться в любом месте программы до своего использования. Затем мы можем определить переменную этой структуры, например, в секции .data

Код (ASM):

.data

center point {}

Здесь определена переменная center, которая представляет структуру point. Для определения переменной структуры применяются фигурные скобки {}.
Доступ к полям структуры
При обращении к полям структуры следует понимать, что в памяти поля структуры располагаются рядом в том порядке, в котором они определены. Для доступа к полю структуры применяется имя переменной структуры (которое по сути представляет адрес структуры) и смещение поля относительно начала структуры. Например:

Код (ASM):

center[0] или center ; обращение к полю Х

center[2] ; обращение к полю y

Поскольку поле x - переменная типа word и занимает 2 байта, то смещение поля y относительно начала структуры будет 2 байта. Пример полностью:

Код (ASM):

point struct ; структура представляет точку

x word ? ; координата Х

y word ? ; координата Y

point ends

.data

center point {}

.code

main proc

mov center[0], 5 ; устанавливаем значения полей

mov center[2], 4

xor rax, rax

mov ax, word ptr center[2] ; EAX = 4

ret

main endp

end

При передаче данных из регистра требуется привести поле структуры к типу регистра:

Код (ASM):

mov rax, 5

mov word ptr center, ax

Несмотря на то, что поле x структуры point представляет тип word, но все равно преобразуем данные в тип word, поскольку получаем данные из 16-разрядного регистра ax.
Поскольку манипулировать смещениями тех или иных полей не очень удобно, особенно когда полей довольно много, то MASM позволяет обращаться к полям по их имени:имя_структуры.имя_поля Например:

Код (ASM):

point struct ; структура представляет точку

x word ? ; координата Х

y word ? ; координата Y

point ends

.data

center point {}

.code

main proc

mov rdx, 5

mov center.x, 6

mov center.y, dx

xor rax, rax

mov ax, word ptr center.y ; EAX = 5

ret

main endp

end

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

Код (ASM):

.data

center point {10, 15}

Здесь x=10, а y=15.
Если поле структуры - набор, то значения этого набора указываются в фигурных скобках:

Код (ASM):

list struct

elements byte 5 dup(?)

list ends

.data

numbers list {{3, 4, 5, 6, 7}}

.code

main proc

xor rax, rax

mov al, byte ptr numbers[2] ; EAX = 5

ret

main endp

end

Массив структур
Также из структур можно создавать массив:

Код (ASM):

point struct ; структура представляет точку

x word ? ; координата Х

y word ? ; координата Y

point ends

.data

;points point 3 dup ({}) ; массив из трех точек

points point{1, 2}

point {3, 4}

point {5,6}

.code

main proc

mov rax, 9

lea rbx, points

mov [rbx + 2*4], al ; обращаемся к координате x третьей точкb

movzx rax, word ptr [rbx + 2*4] ; AX = 9

ret

main endp

end

В данном случае определяется массив из трех точек - структур point. Для обращения к точкам в регистр RBX загружаем адрес массива points. Каждый элемент point в массиве занимает 4 байта (по 2 байта на каждую координату). Поэтому чтобы обратиться к адресу координаты x третьей точки, применяется выражение [rbx + 2*4]. Соответственно для обращения к координате y этой точки, надо к этому адресу прибавить еще 2 байта: [rbx + 2*4+2]
Также можно определять неинициализованный массив структур:

Код (ASM):

.data

points point 3 dup ({}) ; массив из трех точек

Выравнивание в структурах
Для более быстрого обращения к полям структуры можно использовать выравнивание, которое устанавливается с помощью директивы align. Например

Код (ASM):

point3D struct ; структура представляет точку в пространстве

x byte ? ; координата Х

y byte ? ; координата Y

z byte ? ; координата Z

point3D ends

Переменная y здесь будет располагаться по нечетному адресу. Применим выравнивание:

Код (ASM):

point3D struct ; структура представляет точку

x byte ? ; координата Х

align 2 ; выравнивание по двум байтам

y byte ? ; координата Y

z byte ? ; координата Z

point3D ends

Теперь переменная x будет выравнена по 2 байтам - после нее добавляется еще один байт.
Также можно сразу задать выравнивание для всех переменных в определении структуры:

Код (ASM):

point3D struct 2 ; выравнивание всех переменных по двум байтам

x byte ?

y byte ?

z byte ?

point3D ends

Mikl___ · 29 окт 2026 в 16:42

Работа с данными и памятью
Объединения union
Объединения (union) также позволяют определить свой тип данных и также хранят набор элементов, но в отличие от структуры все элементы объединения имеют нулевое смещение. А это значит, что разные элементы занимают в памяти один и тот же участок, то есть в памяти они накладываются друг на друга.
Для определения объединений применяется ключевое слово union и следующий формальный синтаксис:
имя_объединения union
поля объединения
имя_объединения ends
Например, определим простейшее объединение, которое хранит символ и его числовой код из таблицы ASCII:

Код (ASM):

char union ; объединение char представляет символ таблицы ASCII

letter byte ? ; символ

num_code dword ? ; его числовой код

char ends

Здесь определено объединение с именем char, которое хранит в одном и том же участки памяти объект dword (числовой код символа) и объект byte (сам символ). В итоге это объединение будет занимать 4 байта, и младший байт будет общим для переменной letter и num_code. Таким образом, объединение позволяет сэкономить на размее памяти.
Затем мы можем создать переменную, которая представляет данное объединение:

Код (ASM):

.data

symbol char {}

Здесь переменная объединения char называется symbol. Для определения объединения применяются фигурные скобки {}.
Для обращения к полям объединения используется точечная нотация - после имени объединения ставится точка и имя поля:

Код (ASM):

char union ; структура представляет символ таблицы ASCII

letter byte ? ; символ

num_code dword ? ; его числовой код

char ends

.data

symbol char {}

.code

main proc

mov rdx, "c"

mov symbol.letter, dl ; устанавливаем значение letter

mov eax, symbol.num_code ; EAX = 99 - код символа c

ret

main endp

end

Здесь в регистр rdx помещается символ "c", который имеет код 99 в таблице ASCII. Далее этот символ передаем в переменную letter. Но поскольку переменная letter представляет младший байт переменной num_code, то num_code также будет содержать значение 99.

Mikl___ · 30 окт 2026 в 02:32

Базовые конструкции
Условные конструкции
Условные конструкции позволяют направить действие программы по одному из путей в зависимости от определенного условия. В языке ассемблера нет подобных конструкций в отличие от языков высокого уровня. Однако, используя сравнение значения флагов, метки и переходы, мы можем сами определить подобные конструкции.
Имитация конструкции if..else
Во многих распространеных языках высокого уровня есть конструкция if..else, которая в зависимости от условия выполняет те или иные действия. С помощью бейсикоподобного синтаксиса обобщенно эту конструкцию можно представить следующим образом:
IF условие THEN
выполняемые действия, если условие верно
ELSE
выполняемые действия, если условие НЕ верно
END IF
Или конструкция if..else в большинстве сиподобных языков
if(условие)
{
выполняемые действия, если условие верно
}
else
{
выполняемые действия, если условие НЕ верно
}
Например, сначала возьмем простейшую форму конструкции if, которая сравнивает два числа и, если они равны, устанавливает некоторую переменную. Например, на сиподобном языке это выглядело бы так:
if(a == b)
{
eax = 1;
}
Чтобы определить подобную конструкцию на языке ассемблера, вначале указываются операторы, которые оценивают выражение, а затем выполняют переход, если условие неверно.

Код (ASM):

.data

a dword 22

b dword 22

.code

main proc

mov eax, a

begin_if:

cmp eax, b ; сравниваем a и b

jne end_if ; если a и b не равны - к метке end_if

mov eax, 1 ; если a и b равны

end_if:

ret

main endp

end

Для большей наглядности здесь определена необязательная метка begin_if, которая условно определяет начало конструкции. С помощью инструкции cmp сравниваем два значения и далее, если два числа не равны, переходим к метке end_if, которая знаменует конец конструкции.
Конструкция if во многих языках также позволяет задать альтернативные условия (обычно для этого применяется оператор else). В этом случае в ассемблере надо использовать дополнительную метку, на которую будут проецироваться альтернативные действия

Код (ASM):

cmp X, Y ; проверяем условие

jcc ElseCode ; если условие не верно

действия, если условие верно

jmp EndOfIf

ElseCode:

действия, если условие не верно

EndOfIf:

Например, если условие верно, в EAX поместим 1, если не верно - 0:

Код (ASM):

.data

a dword 24

b dword 22

.code

main proc

mov eax, a

begin_if:

cmp eax, b ; сравниваем a и b

jne else_if ; если условие не верно - к метке else_if

mov eax, 1 ; если a и b равны

jmp end_if ; в конец конструкции id

else_if:

mov eax, 0 ; если a и b не равны

end_if:

ret

main endp

end

Здесь, если условие не верно (a и b не равны), то переходим к метке else_if, после которой определено альтернативное действие.
Сложные условия
Когда условие очень простое, то его довольно легко описать на языке ассемблера. Однако если условие комплексное и состоит из ряда простых, то это может привести к значительному усложнению кода ассемблера.
Операция AND
Например, возьмем условие, которое состоит из двух подусловий, объединенных операцией AND:
if((a == b) && (c != d)) {действия}
то есть, условие истинно, если одновременно a равно b и c не равно d. Фактически мы можем представить это выражение как:
if(a == b) if(c != d) {действия}
С точки зрения ассемблера нам надо последовательно проверить все условия, которые связаны операцией AND:

Код (ASM):

.data

a dword 22

b dword 22

c dword 24

d dword 25

.code

main proc

begin_if:

mov eax, a

cmp eax, b ; (a==b)

jne end_if ; если первое условие не верно

mov eax, c

cmp eax, d ; (c!=d)

je end_if ; если второе условие не верно

mov eax, 1 ; если оба условия верны

end_if:

ret

main endp

end

То есть проверяем первое условие. Если оно неверно, переходим к концу конструкции if. Если первое условие верно, переходим к проверке второго условия. Если второе условие неверно, переходим к концу конструкции if. Если второе условие верно, выполняем указанные действия.
Операция OR
Другой распространенный способ объединения условий представляет операция OR или логическое ИЛИ:
if((a == b) || (c != d)) {действия}
то есть, условие истинно, если или a равно b, или c не равно d. Фактически мы можем представить это выражение как:
if(a == b) {действия}
else if(c != d) {действия}
Если верно одно из условий, то выполняются те же самые действия.
С точки зрения ассемблера нам надо последовательно проверить все условия, которые связаны операцией OR:

Код (ASM):

.data

a dword 22

b dword 22

c dword 24

d dword 25

.code

main proc

begin_if:

mov eax, a

cmp eax, b ; (a==b)

je do_if ; если первое условие верно переходим к do_if

mov eax, c

cmp eax, d ; (c != d)

je end_if ; если второе условие не верно (то есть если с == d), выходим

do_if:

mov eax, 1 ; если одно из условий верно

end_if:

ret

main endp

end

Сначала проверяем первое условие. Если оно верно, переходим к выполнению действий. Если первое условие неверно, проверяем второе условие. Если второе условие верно, переходим к выполнению действий. Если второе условие тоже не верно, переходим к концу конструкции.
AND и OR
На основе выше указанной информации мы можем переложить на ассемблер более сложные условия, например, которые сочетают операции AND и OR:
if(((a == b) && (c != d)) || (e == f)) {действия}
В данном случае общее условие истинно, если либо верно подусловие (a == b) && (c != d), либо (e == f). При составлении программы на языке ассемблера целесообразнее вначале проверить третье условие:

Код (ASM):

.data

a dword 22

b dword 22

c dword 23

d dword 24

e dword 25

f dword 26

.code

main proc

begin_if:

mov eax, e

cmp eax, f ; (e==f)

je do_if ; если третье условие верно переходим к do_if

mov eax, a

cmp eax, b ; (a==b)

jne end_if ; если первое условие не верно

mov eax, c

cmp eax, d ; (c!=d)

je end_if ; если второе условие не верно

do_if:

mov eax, 1 ; если одно из условий верно

end_if:

ret

main endp

end

То есть вначале проверяем третье условие. Если оно верно, то проверка первых двух условие не имеет смысла, и поэтому переходим к выполнению действий в метку do_if. Если третье условие не верно, то последовательно проверяем первое и второе условие. Если одно из них неверно, то переходим к концу конструкции в метке end_if.
Если нам важен порядок выполнения, то мы могли бы написать так:

Код (ASM):

.data

a dword 21

b dword 22

c dword 23

d dword 24

e dword 25

f dword 26

.code

main proc

begin_if:

mov eax, a

cmp eax, b ; (a==b)

jne or_if ; если первое условие не верно

mov eax, c

cmp eax, d ; (c!=d)

jne do_if ; если второе условие верно

or_if:

mov eax, e

cmp eax, f ; (e==f)

jne end_if ; если третье условие верно переходим к do_if

do_if:

mov eax, 1 ; если одно из условий верно

end_if:

ret

main endp

end

Проверяем первое условие. Если оно неверно, переходим к метке or_if к проверке третьего условия. Если первое условие верно, переходим к проверке второго условия. Если второе условие верно, то проверять третье условие смысла нет, и переходим к метке do_if и выполнению указанных инструкций.

Mikl___ · 30 окт 2026 в 02:49

Базовые конструкции
Булевые конструкции
Многие языки программирования оценивают условия как значения логических типов (обычно называются bool или boolean). В ассемблере мы также можем представить условия в виде своего рода логических значений, а по сути чисел, которые равны или 1 (условие верно) или 0 (условие не верно). Для примера возьмем условие
if(((a == b) && (c != d)) || (e == f))[/TD][/TR][/TBODY]
С помощью инструкции setXX в зависимости от результата проверки мы можем установить условные логические значения

Код (ASM):

.data

a dword 22

b dword 22

c dword 23

d dword 24

e dword 25

f dword 26

.code

main proc

begin_if:

mov eax, a

cmp eax, b ; (a==b)

sete bl ; результат сравнения (a==b) в регистре BL

mov eax, c

cmp eax, d ; (c!=d)

setne bh ; результат сравнения (c!=d) в регистре BH

and bl, bh ; Помещаем в регистр BL результат (a==b) && (c!=d)

mov eax, e

cmp eax, f ; (e==f)

sete bh ; результат сравнения (e==f) в регистре BH

or bl, bh ; Помещаем в регистр BL результат (((a == b) && (c != d)) || (e == f))

je end_if ; если все условие не верно, переходим к end_if

mov eax, 1 ; если условие верно

end_if:

ret

main endp

end

Здесь вначале проверяем первое условие из подусловия AND - (a==b):

Код (ASM):

mov eax, a

cmp eax, b ; (a==b)

sete bl ; результат сравнения (a==b) в регистре BL

Если числа a и b равны, то в регистр BL помещается 1.
Затем проверяем второе условие из подусловия AND - (c!=d):

Код (ASM):

mov eax, c

cmp eax, d ; (c!=d)

setne bh ; результат сравнения (c!=d) в регистре BH

Если числа c и d не равны, то в регистр BH помещается 1.
Далее с помощью инструкции and можно оценить весь результат подусловия AND:

Код (ASM):

and bl, bh ; Помещаем в регистр BL результат (a==b) && (c!=d)

Таким образом, если оба условия истинны, то в регистре BL будет 1, иначе будет 0.
Затем проверяем третье условие - подусловие OR - (e==f):

Код (ASM):

mov eax, e

cmp eax, f ; (e==f)

sete bh ; результат сравнения (e==f) в регистре BH

И с помощью инструкции or проверяем результат всего условия (((a == b) && (c != d)) || (e == f))

Код (ASM):

or bl, bh ; Помещаем в регистр BL результат (((a == b) && (c != d)) || (e == f))

je end_if ; если все условие не верно, переходим к end_if

Если оба регистра равны 0 (оба подусловия неверны), то устанавливается флаг нуля. Соответственно мы можем проверить этот флаг и, если он установлен, перейти к метке завершения конструкции if.
Стоит отметить, что примере выше вычисления производились в полной форме, все три условия вычислялись. Однако, если мы возьмем подусловие (a == b) && (c != d), то тут нет смысла вычислять второе условие, если первое условие не верно. Аналогично если верно улсовие ((a == b) && (c != d)), то подусловие (e == f) нет смысла вычислять. Поэтому в определенных ситуациях может быть предпочтительно вычисление по укороченной схеме или то что называется "short-circuit", как было продемонстрировано в предыдущем примере.

Mikl___ · 30 окт 2026 в 02:55

Базовые конструкции
Имитация конструкции switch..case
В ряде языков высокого уровня есть конструкция switch..case, которая последовательно сравнивает некоторое выражение с набором значений:
switch(выражение){
case значение_1: действия_1;
case значение_2: действия_2;
case значение_3: действия_3;
default: действия_по_умолчанию;
}
Если найдено совпадение, то выполняются инструкции из соотвествующего блока case
Общий алгоритм данной конструкции может быть следующим:

С помощью инструкции CMP сравниваем значение регистра с некоторым значением.

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

Если ни одно из сравнений в инструкциях CMP НЕ является верным, выполняем действия по умолчанию.

Пример реализации:

Код (ASM):

.data

number dword 2

.code

main proc

mov eax, number ; сравниваемое значение

cmp eax, 1 ; number == 1

jne case_2 ; если не равно, переходим к метке case_2

mov eax, 11 ; действия, если числа равны

jmp end_switch ; выходим из конструкции

case_2:

cmp eax, 2 ; number == 2

jne case_2 ; если не равно, переходим к метке case_3

mov eax, 22 ; действия, если числа равны

jmp end_switch ; выходим из конструкции

case_3:

cmp eax, 3 ; number == 3

jne default ; если не равно, переходим к мет

mov eax, 33 ; действия, если числа равны

jmp end_switch ; выходим из конструкции

default:

mov eax, 44 ; действия по умолчанию, если предыдущие равенства не верны

end_switch: ; конец конструкции

ret

main endp

end

Здесь значение переменной number последовательно сравнивается с тремя значениями, и в зависимости от результатов сравнения в регистр eax помещается то или иное значение.
Поскольку достижение последней метки требует большего времени, то сравнения с наиболее вероятными значениями следует помещать ближе к началу конструкции.
Оптимизация
Приведенный выше пример довольно просто, однако имеет один большой недостаток - при большом количестве меток потребуется некоторое время чтобы дойти до последней метки. Например, если число равно 10, то будет выполняться кода на метке default. Но чтобы дойти до нее надо пройти все предыдущие метки и инструкции сравнения. При большом количестве переходов и меток это несколько снижает производительность. И здесь есть различные возможности оптимизации программы.
Если сравниваемые значения располагаются последовательно, как примере выше - 1, 2, 3, то эффективнее определить набор меток, к которым происходит переход при помощи косвенной адресации:

Код (ASM):

.data

number dword 2

.code

main proc

mov eax, number ; сравниваемое значение

cmp eax, 1

jb default ; если меньше 1

cmp eax, 3

ja default ; если больше 3

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

jmp qword ptr [rcx][rax * 8 - 8] ; переходим к одной из меток

labels qword case_1, case_2, case_3 ; адреса меток

case_1:

mov eax, 11 ; действия, если числа равны

jmp end_switch ; выходим из конструкции

case_2:

mov eax, 22 ; действия, если числа равны

jmp end_switch ; выходим из конструкции

case_3:

mov eax, 33 ; действия, если числа равны

jmp end_switch ; выходим из конструкции

default:

mov eax, 44 ; действия по умолчанию, если предыдущие равенства не верны

end_switch: ; конец конструкции

ret

main endp

end

Здесь опять же сравниваем с теми же числами - 1, 2, 3. Вначале проверяем попадает ли число в этот диапазон - если оно меньше 1 и больше 3, то переходим к метке default. Для остальных переходов определяем специальную переменную - labels, которая хранит адреса трех меток. Важно, что эта переменная определена в таком месте процедуры, в где она точно не будет выполняться как инструкция - в данном случае перед переменной идет переход к одной из меток.
Адрес этой переменной загружается в регистр RCX. И далее на основе значения в регистре EAX вычисляем адрес и переходим к нему:

Код (ASM):

jmp qword ptr [rcx][rax * 8 - 8]

То есть [rcx] представляет адрес переменной labels. Адрес первой метки это также [rcx] или [rcx] + 0. В RAX мы ожидаем число 1, 2 или 3. Соответственно с помощью выражения [rax * 8 - 8] мы можем вычислить смещение метки для определенного числа в EAX. Например, если в EAX число 2, то мы получим [rcx][2*8-8] или [rcx][8], то есть адрес метки case_2.
Но что, если нам надо сравнить с числами, которые идут не по порядку, например, 1, 2, 4, 8? Здесь между числами небольшой разбор - от 1 до 8, и мы могли бы сделать так:

Код (ASM):

.data

number dword 2

.code

main proc

mov eax, number ; сравниваемое значение

cmp eax, 1

jb default ; если меньше 1

cmp eax, 8

ja default ; если больше 8

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

jmp qword ptr [rcx][rax * 8 - 8]

labels qword case_1, case_2, default, case_4,

default, default, default, case_8 ; адреса меток

case_1:

mov eax, 12

jmp end_switch

case_2:

mov eax, 23

jmp end_switch

case_4:

mov eax, 45

jmp end_switch

case_8:

mov eax, 89

jmp end_switch

default:

mov eax, 101 ; действия по умолчанию, если предыдущие равенства не верны

end_switch: ; конец конструкции

ret

main endp

end

Здесь все то же самое, только теперь адресов меток у нас 8, но 4 из них - адреса метки default. То есть если у нас будут для сравнения числа 3, 5, 6, 7, то для них будет выбираться метка default.
Хотя в примере выше сравниваемые значение не идут по порядку, но все равно находятся довольно близко - в пределах первой восьмерки. Что делать, если разброс значений гораздо больше, например, 1, 2, 10, 11, 100, 101, 103, 1000, 1001? В этом случае мы можем сгруппировать близкие значения в отдельные группы и для каждой групп определить свой набор меток:

Код (ASM):

.data

number dword 2

.code

main proc

mov eax, number ; сравниваемое значение

cmp eax, 100

jb case0_11

cmp eax, 103

ja case1000_1001

lea rcx, labels100

jmp qword ptr [rcx][rax * 8 - 100 * 8]

labels100 qword case_100, case_101, default, case_103 ; метки для 100, 101, 103

case0_11:

cmp eax, 11

ja default ; если больше 10

lea rcx, labels0_11

jmp qword ptr [rcx][rax * 8]

labels0_11 qword default, case_1, case_2, default, default, default, default,

default, default, default, case_10, case_11

case1000_1001:

cmp eax, 1000

jb default

cmp eax, 1001

ja default

lea rcx, labels1000

jmp qword ptr [rcx][rax * 8 - 1000 * 8]

labels1000 qword case_1000, case_1001

case_1:

mov eax, 21

jmp end_switch

case_2:

mov eax, 22

jmp end_switch

case_10:

mov eax, 23

jmp end_switch

case_11:

mov eax, 24

jmp end_switch

case_100:

mov eax, 25

jmp end_switch

case_101:

mov eax, 26

jmp end_switch

case_103:

mov eax, 26

jmp end_switch

case_1000:

mov eax, 27

jmp end_switch

case_1001:

mov eax, 28

jmp end_switch

default:

mov eax, 30 ; действия по умолчанию, если предыдущие равенства не верны

end_switch: ; конец конструкции

ret

main endp

end

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

Mikl___ · 30 окт 2026 в 03:22

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

Код (ASM):

.data

state byte 0 ; условное состояние

.code

state_machine proc

state_0:

cmp state, 0 ; сраниваем состояние

jne state_1

add eax, ecx ; состояние 0: складываем ECX и EAX и переключаемся на состояние 1

inc state ; изменяем состояние

jmp exit

state_1:

cmp state, 1

jne state_2

sub eax, ecx ; состояние 1: вычитаем ECX из EAX и переключаемся на состояние 2

inc state ; изменяем состояние

jmp exit

state_2:

cmp state, 2

jne state_3

imul eax, ecx ; состояние 2: умножаем ECX на EAX и переключаемся на состояние 3

inc state ; изменяем состояние

jmp exit

state_3:

; cmp state, 3 ; предположим, что это состояние будет в любом случае, но также можно сравнивать

xor edx, edx ; для деления расширяем нулями регистр EAX на EDX

div ecx ; состояние 3: делим EAX на ECX и переключаемся на состояние 0

mov state, 0 ; изменяем состояние

exit:

ret

state_machine endp

main proc

mov eax, 5

mov ecx, 4

call state_machine

ret

main endp

end

Для данной программы предположим, что все возможные состояния описываются числами 0, 1, 2, 3, которые представляют определенную арифметическую операцию: сложение (0), вычитание (1), умножение (3) и деление (4). Для хранения состояния в программе определена переменная state. Для управления состоянием определена процедура state_machine, в которой мы сравниваем значение state с возможными состояниями. Если сравнение успешно, выполняем арифметическую операцию и изменяем состояние. Либо переходим к следующей метке для проверки нового состояния.
Через регистры EAX и ECX процедура state_machine получает значения:

Код (ASM):

mov eax, 5

mov ecx, 4

call state_machine

Таким образом, после выполнения процедуры будет выполняться операция сложения (так как переменная state на старте программы равна 0). В EAX окажется число 9, а переменная state получит значение 1.
Подобным образом мы могли бы несколько раз вызывать процедуру state_machine, передавая ей через RCX различные значения:

Код (ASM):

main proc

mov eax, 5

mov ecx, 4

call state_machine ; EAX = 9, state = 1

mov ecx, 3

call state_machine ; EAX = 6, state = 2

mov ecx, 4

call state_machine ; EAX = 24, state = 3

mov ecx, 2

call state_machine ; EAX = 12, state = 0

ret

main endp

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

Код (ASM):

.data

state qword state_0 ; условное состояние

.code

option noscoped ; делаем метки глобальными

state_machine proc

jmp state

state_0:

add eax, ecx ; состояние 0: складываем ECX и EAX и переключаемся на состояние 1

lea rcx, state_1

mov state, rcx

ret

state_1:

sub eax, ecx ; состояние 1: вычитаем ECX из EAX и переключаемся на состояние 2

lea rcx, state_2

mov state, rcx

ret

state_2:

imul eax, ecx ; состояние 2: умножаем ECX на EAX и переключаемся на состояние 3

lea rcx, state_3

mov state, rcx

ret

state_3:

xor edx, edx ; для деления расширяем нулями регистр EAX на EDX

div ecx ; состояние 3: делим EAX на ECX и переключаемся на состояние 0

lea rcx, state_0

mov state, rcx

ret

state_machine endp

main proc

mov eax, 5

mov ecx, 4

call state_machine ; EAX = 9, state = state_1

mov ecx, 3

call state_machine ; EAX = 6, state = state_2

mov ecx, 4

call state_machine ; EAX = 24, state = state_3

mov ecx, 2

call state_machine ; EAX = 12, state = state_0

ret

main endp

end

Теперь состояния представляют метки state_N, на которые процецируются действия. Чтобы глобальная переменная state могла хранить адрес определенной метки внутри процедуры, перед процедурой указываем директиву option noscoped. В самой процедуре с помощью инструкции jmp сразу переходим к нужному состоянию:

Код (ASM):

jmp state

Mikl___ · 30 окт 2026 в 03:47

Базовые конструкции
Циклы
Циклические конструкции позволяют выполнить некоторый набор инструкций определенное количество раз. На ассемблере можно реализовать различные типы циклов различным образом. Но, как правило, они вовлекают инструкцию сравнения результатов CMP и переход к определенной метке.
while
В ряде языков программирования есть тип циклов - цикл while, который выполняет некоторые действия, пока истинно некоторое условие:

BASIC-подобный синтаксис C-подобный синтаксис
WHILE условие
действия цикла
END WHILE while(условие){
действия цикла
}
Пример цикла на сиподобных языках:
i = 0;
while(i < 100)
{
i++;
}
Здесь в цикле увеличиваем переменную i на 1, пока она меньше 100. Когда переменная i окажется равна 100, выходим из цикла.
Реализация подобного цикла на ассемблере:

Код (ASM):

.data

i dword 0

.code

main proc

mov i, 0

while_start:

cmp i, 10

jnl while_end ; если i не меньше 10, переход к метке while_end

; выполняемые действия

inc i

jmp while_start

while_end:

mov eax, i ; EAX = 10

ret

main endp

end

Здесь метка while_start знаменует начало цикла, в котором сначала сравниваем значение i с числом 10. Если значение i НЕ меньше 10 (jnl), переходим к концу цикла - метке while_end. Иначе инкрементируем значение переменной и переходим к началу цикла - метке while_start.
цикл do..while
Еще одним типом циклов является цикл do..while - он сначала выполняет некоторые действия, а потом проверяет условие. Если условие верно, повторяет действия. Если условие НЕ верно, завершает работу:

C-подобный синтаксис
do{
выполняемые действия
}
while(условие);
С точки зрения реализации на ассемблере это самый легкий тип цикла:

Код (ASM):

.code

main proc

mov eax, 1 ; помещаем в регистр EAX число 1

do_while:

; выполняемые действия

add eax, 1 ; действия цикла - EAX = EAX + 1

cmp eax, 10 ; сравнивание значение регистра EAX с числом 10

jl do_while ; если EAX меньше 10, переход к метке do_while

ret

main endp

end

Здесь помещаем в регистр EAX число 1. Затем после метки do_while производим действия цикла - увеличиваем значение регистра X0 на единицу. Далее сравниваем значение регистра EAX с числом 10. И если EAX меньше числа 10, то переходим обратно к метке do_while и повторяем действия цикла. Когда EAX станет равным 10, то произодейт выход из цикла.
цикл for
В ряде языков высокого уровня, например, есть циклическая конструкция for:

BASIC-подобный синтаксис C-подобный синтаксис
FOR i = M TO N
выполняемые действия
NEXT i for(var i = M; i < N; i++)
{
выполняемые действия
}
то есть есть некоторый счетчик i, и пока этот счетчик не достигнет значения N, будут выполняться некоторые действия цикла.
Реализация цикла for в ассемблере:

Код (ASM):

.code

main proc

mov eax, 0 ; в EAX помещаем число - условный счетчик

for_start: ; метка, на которую проецируется цикл

cmp eax, 10 ; сравниваем с некоторым пределом

jnl for_end ; условие - если счетчик больше или равен пределу, выход из цикла

; выполняемые действия

add eax, 1 ; действия цикла - увеличение счетчика

jmp for_start ; повторяем цикл

for_end:

ret

main endp

end

В данном случае в EAX помещаем некоторое значение, которое будет выполнять роль счетчика цикла. Собственно цикл начинается с метки for_start. Сначала мы проверяем условие. Допустим, нам надо, чтобы цикл повторялся, пока в регистре EAX не окажется число 10. Если в EAX чило 10 или больше, то выходим из цикла - переходим к метке for_end. Если в EAX все еще меньше 10, то выполняем действия цикла - увеличиваем EAX на 1 и затем переходим обратно к метке for_start для повторения цикла.
Оптимизация циклов
Если мы посмотрим на ассемблерную реализацию циклов while и for, то увидим, что они в принципе похожи:

Код (ASM):

;цикл while

mov eax, 0

while_start:

cmp eax, 10

jnl while_end

add eax, 1

jmp while_start

while_end:

; цикл for

mov eax, 0

for_start:

cmp eax, 10

jnl for_end

add eax, 1

jmp for_start

for_end:

Такая реализация очень проста и понятна. Однако реализация цикла do_while гораздо эффективнее

Код (ASM):

mov eax, 1

do_while:

add eax, 1

cmp eax, 10

jl do_while

В отличие от while/for здесь отсутствует инструкция jmp, и сама конструкция будет теоретически выполняться быстрее. Но в циклах while/for нам важно выполнять определенные действия только при соблюдении некоторого условия. Соответственно это условие вначале надо проверить. Однако мы могли бы вынести действия цикла вперед:

Код (ASM):

.code

main proc

mov eax, 0

jmp for_condition ; переходим к проверке условия

for_start:

add eax, 1

for_condition:

cmp eax, 10

jl for_start ; если условие соблюдено переходим к метке for_start для выполнения действий

ret

main endp

end

Здесь цикл начинается с перехода к метке for_condition, где проверяется условие - EAX должен быть меньше 10. Если это условие верно, переходим к метке for_start, где выполняем действия цикла. Затем опять проверяем условия и выполняем действия цикла, пока не дойдем до ситуации, когда EAX = 10.
Таким образом, инстркция jmp выполняется только один раз, а в остальном цикл for/while будет соответствовать циклу do-while.
Но и цикл do-while мы тоже можем до некоторой степени оптимизировать. Перепишем пример следующим образом:

Код (ASM):

.code

main proc

mov eax, 9 ; помещаем в регистр EAX число 9

do_while:

; выполняемые действия

sub eax, 1 ; действия цикла - EAX = EAX - 1

jnz do_while ; если флаг нуля установлен, то есть EAX=0, переход к метке do_while

ret

main endp

end

Здесь идет обратный отсчет - от 9 до 1. И теперь значение в регистре EAX уменьшается на 1. Но цикл срабатывает столько же раз, сколько и в предыдущей реализации. Поскольку когда результат операции sub окажется равен 0 (то есть EAX = 0), то будет установлен флаг нуля. Соответственно мы можем проверить этот флаг, и если он еще не установлен, продолжить цикл. Таким образом, мы отбрасываем инструкцию cmp, поскольку нам не надо вручную сравнивать значения.
Если нам надо, чтобы EAX допускал значение 0 (от 9 до 0 - в этом случае флаг нуля мы так проверить не сможем), то мы можем проверять флаг знака, который устанавливается, если результат отрицательный:

Код (ASM):

.code

main proc

mov eax, 9 ; помещаем в регистр EAX число 9

do_while:

; выполняемые действия

sub eax, 1 ; действия цикла - EAX = EAX - 1

jns do_while ; если флаг знака SF =1, переход к метке do_while

ret

main endp

end

Mikl___ · 30 окт 2026 в 15:38

Арифметика больших чисел
Сложение и вычитание больших чисел
Поскольку регистры общего назначения в архитектуре x86-64 64-разрядные, то загрузить в один регистр число большей разрядности у нас не получится. Тем не менее мы не ограничены только 64-разрядными числами и можем работать с числами большей разрядности, например, 128-, 192-, 256-битными и т.д.
Например, возьмем 128-разрядные числа. Определенно такое число не помещается в один 64-разрядный регистр. Но мы можем разбить число и поместить его младшие 64 бита в один регистр, а старшие 64 бита в другой. Аналогично 192-разрядные числа разносятся по трем 64-разрядным регистрам.
При работе с большими числами, которые не укладываются в рамки одного регистра, основная идея состоит в том, чтобы разбить большую операцию на последовательность более мелких. Поскольку семейство процессоров x86 способно одновременно складывать не более 64 бит (используя регистры общего назначения), операция должна выполняться блоками по 64 бита или меньше.
Сложение больших чисел
Например, возьмем сложение 128-разрядных чисел. Сначала складываем младшие 64 разряда чисел. Если при сложении новое число выходит за пределы 64 бит, то процессор устанавливает флаг переноса CF. Затем складываем старшие 64 бита чисел и бит переноса.
Для сложения двух операндов с битом переноса применяется инструкция adc
adc dest, source ; dest = dest + source + CF
Она, как и инструкция add, складывает два числа, но также к результату добавляет бит из флага переноса CF. Рассмотрим пример:

Код (ASM):

.data

x oword 01ffffffffffffffffh

y oword 010000000000000002h

z oword ?

.code

main proc

mov rax, qword ptr x ; В RAX загружаем младшие 64 бита числа x

add rax, qword ptr y ; складываем их с младшими 64 битами числа y

mov qword ptr z, rax ; результат сложения помещаем в младшие 64 бита числа z

mov rax, qword ptr x[8] ; В RAX загружаем старшие 64 бита числа x

adc rax, qword ptr y[8] ; складываем их со старшими 64 битами числа y и с битом переноса

mov qword ptr z[8], rax ; результат сложения помещаем в младшие 64 бита числа z

ret

main endp

end

Для хранения данных здесь определяем три переменных типа oword (восьмеричное слово - 128-разрядное число). Сначала помещаем в регистр RAX младшие 64 бита переменной x и складываем их с младшими 64 битами переменной y. Чтобы получить младшие 64 бита, оператор qword ptr приводит переменные x, y и z к 64 битам (по сути берет младшие 64 бита).
После сложения младших 64 бит складываем старшие 64 бита. Для этого помещаем в RAX старшие 64 бита переменной x, складываем их со старшими 64 битами переменной y и помещаем результат в старшие 64 разряда переменной z. Чтобы получить старшие 64 бита, применяется выражение в форме x[8] вместе с оператором qword ptr (число 8 указывает на 8 байт).
В итоге мы получаем вычисления
01ffffffffffffffffh + 010000000000000002h = 030000000000000001h
В младших 64 бита будет число 1, а в старших 64 битах - число 3.
Подобным механизм можно распространить на числа и большей разрядности. Например, возьмем сложение 192-разрядных чисел:

Код (ASM):

.data

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

0ffffffffffffffffh, ; средние 64 бит

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

BigInt2 qword 00000000000000002h,

00000000000000000h,

00000000000000001h

BigInt3 qword 3 dup (?)

.code

main proc

mov rax, BigInt1[0]

add rax, BigInt2[0]

mov BigInt3[0], rax

mov rax, BigInt1[8] ; 64 бита начиная с 8 байт

adc rax, BigInt2[8]

mov BigInt3[8], rax

mov rax, BigInt1[16] ; 64 бита начиная с 16 байт

adc rax, BigInt2[16]

mov BigInt3[16], rax

ret

main endp

end

Здесь каждое число представлено переменной BigInt1/BigInt2/BigInt3, которое по сути представляет набор из 3 значений qword - младших, средних и старших 64 бит числа. И мы также по отдельности складываем эти части. А для учета при сложении флага переноса применяем инструкцию adc. То есть получаем вычисления
0000000000000001 ffffffffffffffff ffffffffffffffffh + 0000000000000001 0000000000000000 00000000000000002h = 0000000000000003 0000000000000000 00000000000000001h
Вычитание больших чисел
Аналогично можно применять вычитание больших чисел, разрядность которых больше 64 бит. В этом случае для вычитания младших 64 бит применяется стандартная инструкция sub, а для вычитания последующих 64 бит применяется инструкция sbb ("subtract with borrow" или вычитание с заимствованием), которая имеет аналогичный синтаксис:
sbb dest, source ; dest=dest-source-CF
Из dest вычитается source и бит флага переноса, который устанавливается при заимствовании. И результат помещается в dest
Рассмотрим пример:

Код (ASM):

.data

x oword 030000000000000001h

y oword 01ffffffffffffffffh

z oword ?

.code

main proc

mov rax, qword ptr x ; помещаем в RAX младшие 64 бит числа x

sub rax, qword ptr y ; вычитаем из RAX младшие 64 бит числа y

mov qword ptr z, rax ; результат помещаем в младшие 64 бит числа z

mov rax, qword ptr x[8] ; помещаем в RAX старшие 64 бит числа x

sbb rax, qword ptr y[8] ; вычитаем из RAX старшие 64 бит числа y

mov qword ptr z[8], rax ; результат помещаем в старшие 64 бит числа z

ret

main endp

end

Здесь из 128-разрядного числа x вычитаем другое 128-разрядное число y. Сначала вычитаем из младшие 64 бита, а затем старшие. Таким образом получим:
30000000000000001h - 1ffffffffffffffffh = 10000000000000002h
Если смотреть поэтапно, то сначала вычитаем младшие 64 бита
0000000000000001h - ffffffffffffffffh = 0000000000000002h
Значение первого числа меньше значения второго числа, поэтому необходимо заимствование в первом числе из старших 64 бит.
Подобным механизм можно вычитать числа большей разрядности. Например, возьмем вычитание 192-разрядных чисел:

Код (ASM):

.data

BigInt1 qword 00000000000000001h, ; младшие 64 бит

00000000000000000h, ; средние 64 бит

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

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

0ffffffffffffffffh, ; средние 64 бит

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

BigInt3 qword 3 dup (?)

.code

main proc

mov rax, BigInt1[0]

sub rax, BigInt2[0]

mov BigInt3[0], rax

mov rax, BigInt1[8] ; средние 64 бита - начиная с 8 байт

sbb rax, BigInt2[8] ; вычитание с заимствованием

mov BigInt3[8], rax

mov rax, BigInt1[16] ; старшие 64 бита - начиная с 16 байт

sbb rax, BigInt2[16] ; вычитание с заимствованием

mov BigInt3[16], rax

ret

main endp

end

Здесь будет идет следующее вычисление:
0000000000000003 0000000000000000 0000000000000001h -
0000000000000001 ffffffffffffffff ffffffffffffffffh = 0000000000000001 0000000000000000 0000000000000002h

Mikl___ · 30 окт 2026 в 15:40

Арифметика больших чисел
Сравнение больших чисел
Сравение чисел с разрядностью больше 64 бит - довольно простой процесс. Cначала сравниваем старшие 64 бита - если они не равны, то сравнивать остальные части двух чисел нет смысла. Если же старшие 64 бита равны, сравниваем следующие 64 разряда чисел. Например, сравним 192-разрядные числа:

Код (ASM):

.data

BigInt1 qword 00000000000000001h, ; младшие 64 бит

00000000000000000h, ; средние 64 бит

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

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

0ffffffffffffffffh, ; средние 64 бит

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

.code

main proc

mov rax, BigInt1[16] ; сравниваем старшие 64 бита

cmp rax, BigInt2[16]

ja First ; если первое число больше

jb Second ; если второе число больше

mov rax, BigInt1[8] ; сравниваем средние 64 бита

cmp rax, BigInt2[8]

ja First

jb Second

mov rax, BigInt1[0] ; сравниваем младшие 64 бита

cmp rax, BigInt2[0]

ja First

jb Second

mov rax, 0 ; если числа равны, в RAX = 0

jmp cmp_end

First:

mov rax, 1 ; если первое число больше, в RAX = 1

jmp cmp_end

Second:

mov rax, -1 ; если второе число больше, в RAX = -1

cmp_end:

ret

main endp

end

В данном случае в зависимости от результата сравнения помещаем в RAX 0, 1 или -1. Поскольку здесь предполагается, что числа беззнаковые, то для сравнения и перехода к определенной метке применяются инструкции ja и jb

Mikl___ · 30 окт 2026 в 15:54

Арифметика больших чисел
Умножение больших чисел
При умножении больших чисел нам надо умножить все части одного числа на все части другого числа и полученные результаты произведений сложить. Например, что такое произведение двух 32 разрядных чисел? Очевидно произведение 32 бит одного числа на 32 бита другого числа. Соответственно произведение двух 64-разрядных чисел - это произведение 64 бит одного числа на 64 бита другого числа. Однако мы можем представлить 64-разрядное число как число, у которого есть старшие 32 бита и младшие 32 бита. Тогда получится, что произведение двух 64-разрядных чисел равно
младшие 32 бита первого числа × младшие 32 бита второго числа
+ старшие 32 бита первого числа × младшие 32 бита второго числа × 2³²
+ младшие 32 бита первого числа × старшие 32 бита второго числа × 2³²
+ старшие 32 бита первого числа × старшие 32 бита второго числа × 2⁶⁴
Что можно представить графически следующим образом:

То есть вычисляем по отдельности произведения всех отдельных 32-разрядных частей двух чисел и складываем их. Рассмотрим пример:

Код (ASM):

.data

op1 qword 0ffffffffffffffffh

op2 qword 16

result oword ?

.code

main proc

; умножаем младшие 32 бита двух чисел

mov eax, dword ptr op1

mul dword ptr op2

mov dword ptr result, eax ; сохраняем младшие 32 бита результата

mov ecx, edx ; сохраняем старшие 32 бита результата

; умножаем младшие 32 бита op1 на старшие 32 бита op2

mov eax, dword ptr op1

mul dword ptr op2[4] ; получаем старшие 32 бита числа op2

add eax, ecx ; добавляем промежуточный результат умножения из ECX

adc edx, 0 ; сложение с битом переноса

mov ebx, eax ; сохраняем промежуточный результат

mov ecx, edx

; умножаем старшие 32 бита op1 на младшие 32 бита op2

mov eax, dword ptr op1[4] ; получаем старшие 32 бита числа op1

mul dword ptr op2 ; умножаем на младшие 32 бита op2

add eax, ebx ; добавляем промежуточный результат умножения из EBX

mov dword ptr result[4], eax ; сохраняем частичный результат

adc ecx, edx ; сложение с битом переноса

; умножаем старшие 32 бита двух чисел

mov eax, dword ptr op1[4]

mul dword ptr op2[4]

add eax, ecx ; добавляем промежуточный результат из ECX

adc edx, 0 ; сложение с битом переноса

mov dword ptr result[8], eax ; сохраняем младшую часть результата

mov dword ptr result[12], edx ; сохраняем старшую часть результата

mov eax, dword ptr result[8] ; eax = 15 или 0fh

ret

main endp

end

Здесь умножаем два числа типа qword (то есть 64-разрядные числа) - op1 и op2. Результат теоретически может быть 128-разрядным, и для его хранения определяем переменную result, которая представляет тип oword (128-разрядное число). Умножать мы будем по отдельности 32 бита каждого из числа. То есть у нас идет умножение 32 бита на 32 бита, поэтому результат будет располагаться в регистрах EAX (младшие 32 бита результата) и EDX (старшие 32 бита). Для беззнакового умножения применяем инструкцию mul, для которой первый операнд всегда помещается в EAX.

Вначале умножаем младшие 32 бита обоих чисел:

Код (ASM):

mov eax, dword ptr op1

mul dword ptr op2

mov dword ptr result, eax ; сохраняем младшие 32 бита результата

mov ecx, edx

Младшие 32 бита, которые помещаются в EAX, сохраняем в младшие 32 бита переменной result. Старшие 32 бита - в регистр ECX.

Далее умножаем младшие 32 бита op1 на старшие 32 бита op2:

Код (ASM):

mov eax, dword ptr op1

mul dword ptr op2[4] ; получаем старшие 32 бита числа op2

add eax, ecx ; добавляем промежуточный результат умножения из ECX

adc edx, 0 ; сложение с битом переноса

mov ebx, eax ; сохраняем промежуточный результат

mov ecx, edx

Запись op2[4] означает, что получаем данные начиная с 5 байта числа op1.
После умножения младшие 32 бита, которые помещаются в EAX, складываем со старшими 32 битами предыдущего умножения, которые были помещены в регистр ECX. В процессе сложения может возникнуть перенос, и будет установлен флаг переноса. Поэтому бит переноса прибавляем к старшим 32 битам текущего умножения из регистра EDX.

Далее умножаем старшие 32 бита op1 на младшие 32 бита op2:

Код (ASM):

mov eax, dword ptr op1[4] ; получаем старшие 32 бита числа op1

mul dword ptr op2 ; умножаем на младшие 32 бита op2

add eax, ebx ; добавляем промежуточный результат умножения из EBX

mov dword ptr result[4], eax ; сохраняем частичный результат

adc ecx, edx ; сложение с битом переноса

В данном случае мы опять же получаем данные для вторых 32 битов числа result. После умножения младшие 32 бита, которые помещаются в EAX, складываем с младшими 32 битами предыдущего умножения (так как это данные одного порядка) и помещаем результат во вторые 32 бита переменной result. .В процессе сложения может возникнуть перенос, и будет установлен флаг переноса. Поэтому опять же бит переноса прибавляем к старшим 32 битам текущего умножения из регистра EDX и складываем эти данные со старшими битами из предыдущего результата умножения.

На последнем этапе умножаем старшие 32 бита двух чисел.

Код (ASM):

mov eax, dword ptr op1[4]

mul dword ptr op2[4]

add eax, ecx ; добавляем промежуточный результат из ECX

adc edx, 0 ; сложение с битом переноса

mov dword ptr result[8], eax ; сохраняем младшую часть результата

mov dword ptr result[12], edx ; сохраняем старшую часть результата

Младшие биты результата текущего умножения складываем с суммой старших 32 битов предыдущих двух результатов. И сохраняем эти данные в третьи 32 бита числа result. Страшие 32 бита складываем с битом переноса и сохраняем в старшие 32 бита числа result.

И в данном случае мы получим следующие вычисления:
ffffffffffffffffh * 10h (16 в десятичной - аналогично сдвигу влево на 4 разряда) = ffffffffffffffff0h
или 00000000 0000000f ffffffff fffffff0

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

DEC	HEX	BIN	Символ	Описание	DEC	HEX	BIN	Символ	Описание
0	00	00000000	NUL	Ноль/нулевой байт	16	10	00010000	DLE	Ключ связи данных
1	01	00000001	SOH	Начало заголовка	17	11	00010001	DC1	Управление устройством 1
2	02	00000010	STX	Начало текста	18	12	00010010	DC2	Управление устройством 2
3	03	00000011	ETX	Конец текста	19	13	00010011	DC3	Управление устройством 3
4	04	00000100	EOT	Конец передачи	20	14	00010100	DC4	Управление устройством 4
5	05	00000101	ENQ	запрос	21	15	00010101	NAK	Отрицательное подтверждение
6	06	00000110	ACK	Подтверждение	22	16	00000000	SYN	Синхронизация
7	07	00000111	BEL	Сигнал/звонок	23	17	00000000	ETB	Конец передаваемого блока
8	08	00001000	BS	Шаг назад	24	18	00000000	CAN	Отмена
9	09	00001001	HT	Горизонтальная табуляция	25	19	00000000	EM	Конец среды
10	0A	00001010	LF	Перевод строки	26	1A	00000000	SUB	Замена
11	0B	00001011	VT	Вертикальная табуляция	27	1B	00000000	ESC	Выход
12	0C	00001100	FF	Новая страница	28	1C	00000000	FS	Разделитель файлов
13	0D	00001101	CR	Возврат каретки	29	1D	00000000	GS	Разделитель групп
14	0E	00001110	SO	Выключить сдвиг	30	1E	00011110	RS	Разделитель записей
15	0F	00001111	SI	Включить сдвиг	31	1F	00011111	US	Разделитель модулей

DEC	HEX	BIN	Символ	DEC	HEX	BIN	Символ	DEC	HEX	BIN	Символ	DEC	HEX	BIN	Символ
32	20	00100000	пробел	56	38	00111000	8	80	50	01010000	P	104	68	01101000	h
33	21	00100001	!	57	39	00111001	9	81	51	01010001	Q	105	69	01101001	i
34	22	00100010	"	58	3A	00111010	:	82	52	01010010	R	106	6A	01101010	j
35	23	00100011	#	59	3B	00111011	;	83	53	01010011	S	107	6B	01101011	k
36	24	00100100	$	60	3C	00111100	<	84	54	01010100	T	108	6C	01101100	l
37	25	00100101	%	61	3D	00111101	=	85	55	01010101	U	109	6D	01101101	m
38	26	00100110	&	62	3E	00111110	>	86	56	01010110	V	110	6E	01101110	n
39	27	00100111	'	63	3F	00111111	?	87	57	01010111	W	111	6F	01101111	o
40	28	00101000	(	64	40	01000000	@	88	58	01011000	X	112	70	01110000	p
41	29	00101001	)	65	41	01000001	A	89	59	01011001	Y	113	71	01110001	q
42	2A	00101010	*	66	42	01000010	B	90	5A	01011010	Z	114	72	01110010	r
43	2B	00101011	+	67	43	01000011	C	91	5B	01011011	[	115	73	01110011	s
44	2C	00101100	,	68	44	01000100	D	92	5C	01011100	\	116	74	01110100	t
45	2D	00101101	-	69	45	01000101	E	93	5D	01011101	]	117	75	01110101	u
46	2E	00101110	.	70	46	01000110	F	94	5E	01011110	^	118	76	01110110	v
47	2F	00101111	/	71	47	01000111	G	95	5F	01011111	_	119	77	01110111	w
48	30	00110000	0	72	48	01001000	H	96	60	01100000	`	120	78	01111000	x
49	31	00110001	1	73	49	01001001	I	97	61	01100001	a	121	79	01111001	y
50	32	00110010	2	74	4A	01001010	J	98	62	01100010	b	122	7A	01111010	z
51	33	00110011	3	75	4B	01001011	K	99	63	01100011	c	123	7B	01111011	{
52	34	00110100	4	76	4C	01001100	L	100	64	01100100	d	124	7C	01111100	\|
53	35	00110101	5	77	4D	01001101	M	101	65	01100101	e	125	7D	01111101	}
54	36	00110110	6	78	4E	01001110	N	102	66	01100110	f	126	7E	01111110	~
55	37	00110111	7	79	4F	01001111	O	103	67	01100111	g	127	7F	01111111	DEL

Войти или зарегистрироваться

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

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Преобразование данных

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Символы

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Режимы адресации. Косвенная адресация

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Выравнивание

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Стек

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Указатели

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Строки

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Сортировка массива

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Многомерные массивы

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

xlat и поиск в таблицах

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Структуры

Mikl___ Супермодератор Команда форума

Работа с данными и памятью

Объединения union

Mikl___ Супермодератор Команда форума

Базовые конструкции

Условные конструкции

Mikl___ Супермодератор Команда форума

Базовые конструкции

Булевые конструкции

Mikl___ Супермодератор Команда форума

Базовые конструкции

Имитация конструкции switch..case

Mikl___ Супермодератор Команда форума

Базовые конструкции

Машина состояний

Mikl___ Супермодератор Команда форума

Базовые конструкции

Циклы

Mikl___ Супермодератор Команда форума

Арифметика больших чисел

Сложение и вычитание больших чисел

Mikl___ Супермодератор Команда форума

Арифметика больших чисел

Сравнение больших чисел

Mikl___ Супермодератор Команда форума

Арифметика больших чисел

Умножение больших чисел

Быстрый поиск