Перейти к основному содержимому

Типы данных и регистры

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ
Разработчику Архитектору

Дальше: Справочник Assembler

Типы данных и регистры​

Ассемблер — язык низкого уровня, максимально приближенный к машинному коду. Он предоставляет прямой доступ к ресурсам процессора и памяти компьютера. В отличие от языков высокого уровня, таких как Python, Java или C#, ассемблер не оперирует абстрактными типами данных вроде "строка", "целое число" или "булево значение". Вместо этого он работает с блоками памяти фиксированного размера, которые интерпретируются программистом в зависимости от контекста использования.

Для новичка это обычно самый непривычный момент: в asm нет "защитной сетки" типов, которая подскажет несоответствие на этапе компиляции. Поэтому здесь критично держать в голове три вещи одновременно — размер данных, способ интерпретации (signed/unsigned/адрес/текст) и инструкцию, которая эти данные обрабатывает.

Отсутствие типов в классическом смысле​

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

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

Play ITЗагрузка интерактивного демо…

Play ITЗагрузка интерактивного демо…

Блоки памяти как основа представления данных​

Все данные в ассемблере рассматриваются как непрерывные блоки памяти, состоящие из одного или нескольких байтов. Наиболее распространённые единицы измерения памяти в контексте ассемблера:

  • Байт (byte) — 8 бит, минимальная адресуемая единица памяти на большинстве архитектур.
  • Слово (word) — 16 бит (2 байта). Этот термин исторически связан с 16-битными процессорами, такими как Intel 8086.
  • Двойное слово (double word, dword) — 32 бита (4 байта).
  • Четверное слово (quad word, qword) — 64 бита (8 байт).

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

Каждый блок памяти — это просто набор битов. Сам по себе он не содержит метаинформации о своём назначении. Только контекст выполнения программы определяет, как этот блок следует читать и обрабатывать.

Интерпретация данных зависит от контекста​

Одна и та же последовательность байтов может быть интерпретирована множеством способов. Например, байт со значением 0x41 в шестнадцатеричной системе:

  • При выводе на экран как символ в кодировке ASCII будет отображён как латинская буква A.
  • При арифметической операции будет воспринят как десятичное число 65.
  • При использовании в качестве части адреса будет рассматриваться как младший байт указателя.

Ассемблер предоставляет инструкции, которые работают с данными определённого размера. Например, инструкция MOV AL, 65 загружает значение 65 в 8-битный регистр AL. Инструкция MOV AX, 65 загружает то же число в 16-битный регистр AX. Хотя числовое значение одинаково, размер используемого регистра и объём затронутой памяти различаются.

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

Регистры и их роль в работе с данными​

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

  • 8-битные регистры — AL, BL, CL, DL — работают с отдельными байтами.
  • 16-битные регистры — AX, BX, CX, DX — работают со словами.
  • 32-битные регистры — EAX, EBX, ECX, EDX — работают с двойными словами.
  • 64-битные регистры — RAX, RBX, RCX, RDX — работают с четверными словами.

Некоторые регистры имеют специальное назначение. Например, регистр SP (Stack Pointer) указывает на вершину стека, а IP (Instruction Pointer) содержит адрес следующей выполняемой инструкции. Однако даже специализированные регистры хранят просто числа — их смысл определяется архитектурой и текущим контекстом выполнения.

Примеры интерпретации одного и того же блока памяти​

Рассмотрим 4-байтовый блок памяти со значениями: 48 65 6C 6C (в шестнадцатеричной записи).

  • Если прочитать его как последовательность ASCII-символов, получится строка "Hell".
  • Если интерпретировать как 32-битное целое число в формате little-endian (младший байт первый), значение будет равно 0x6C6C6548, что в десятичной системе составляет 1 819 306 312.
  • Если использовать эти байты как часть машинного кода, они могут представлять собой одну или несколько инструкций процессора, в зависимости от архитектуры.

Таким образом, один и тот же фрагмент памяти может выполнять разные функции в разных частях программы. Ассемблер не накладывает ограничений на использование памяти — он лишь предоставляет средства для её чтения, записи и обработки.

Указатели и адреса как данные​

В ассемблере адреса памяти тоже являются числами. Указатель — это просто значение, которое интерпретируется как адрес другой ячейки памяти. Размер указателя зависит от разрядности архитектуры:

  • В 32-битных системах указатель занимает 4 байта.
  • В 64-битных системах — 8 байт.

Инструкции вроде MOV EAX, [EBX] означают — "загрузить в регистр EAX значение, находящееся по адресу, хранящемуся в регистре EBX". Здесь EBX содержит адрес, а не само значение. Такой подход позволяет реализовывать сложные структуры данных — массивы, списки, деревья — даже без встроенной поддержки типов.

section .data
    value dd 42
    ptr   dd value          ; ptr хранит адрес value (32-bit)

section .text
    mov ebx, [ptr]          ; ebx = адрес value
    mov eax, [ebx]          ; eax = *ptr = 42

Разбор:

  • value dd 42 — ячейка с данными.
  • ptr dd value — в ptr лежит адрес value, не число 42.
  • mov ebx, [ptr] загружает этот адрес в регистр-указатель.
  • mov eax, [ebx] — разыменование: читаем 32 бита по адресу из EBX.
  • Двойные скобки в C (**) на asm раскладываются в такие два шага.

Символы и строки​

Строки в ассемблере — это последовательности байтов, каждый из которых представляет символ в определённой кодировке (чаще всего ASCII или UTF-8). Нет встроенного типа "строка". Программист сам определяет:

  • Где начинается строка (адрес первого байта).
  • Как она завершается (например, нулевым байтом \0 в стиле C).
  • Как её обрабатывать (побайтово, как массив, с использованием специальных строковых инструкций вроде LODSB, STOSB и т.д.).

Это даёт полный контроль над обработкой текста, но требует ручного управления длиной, кодировкой и границами.

Числовые данные — знаковые и беззнаковые​

Хотя ассемблер не различает типы, он предоставляет инструкции, учитывающие знак числа. Например:

  • Инструкции ADD, SUB, MUL работают одинаково с битами, независимо от знака.
  • Но инструкции сравнения (CMP) и условные переходы (JG, JL, JA, JB) различают знаковое и беззнаковое сравнение.

Переход JG (Jump if Greater) интерпретирует операнды как знаковые числа, тогда как JA (Jump if Above) — как беззнаковые. Это означает, что программист должен осознанно выбирать инструкции в зависимости от предполагаемой интерпретации данных.

Флаги процессора (например, флаг переноса CF и флаг знака SF) помогают отслеживать результаты операций и принимать решения на основе правильной семантики.

Один и тот же CMP, разные переходы:

    mov eax, 0xFFFFFFFE     ; как беззнаковое: большое; как знаковое: -2
    cmp eax, 5
    ja  unsigned_above      ; сработает: 0xFFFFFFFE > 5 без знака
    jl  signed_less          ; тоже сработает: -2 < 5 со знаком

Разбор:

  • CMP только выставляет флаги, сами регистры не меняются.
  • JA (above) смотрит на беззнаковый порядок и использует CF/ZF.
  • JL (less) смотрит на знаковый порядок и использует SF/OF вместе с ZF.
  • Для одной пары чисел могут быть истинны оба условия — это нормально, если семантика разная.
  • Ошибка "странного if" часто сводится к выбору JG вместо JA (или наоборот).

Мини-проверка перед сравнением значений​

Перед CMP и условным переходом полезно быстро проверить:

  1. Какой размер операндов (8/16/32/64 бит).
  2. Как трактуются значения (со знаком или без).
  3. Какая пара переходов нужна (JG/JL или JA/JB).
  4. Не испорчены ли нужные флаги промежуточной инструкцией.

Такая привычка резко снижает количество "странных" логических багов.

Организация памяти и выравнивание​

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

  • 16-битное слово эффективно читается, если его адрес кратен двум.
  • 32-битное двойное слово — если адрес кратен четырём.
  • 64-битное четверное слово — если адрес кратен восьми.

Выравнивание не является обязательным требованием на всех архитектурах, но его соблюдение ускоряет выполнение программы. Некоторые процессоры (например, ARM в определённых режимах) генерируют исключение при попытке не выровненного доступа к данным. В ассемблере программист сам отвечает за размещение данных и может явно контролировать выравнивание с помощью директив ассемблера, таких как .align или ORG.

Play ITЗагрузка интерактивного демо…

Работа с массивами​

Массив в ассемблере — это последовательность блоков памяти одинакового размера, расположенных подряд. Тип элементов массива определяется программистом. Например, массив байтов занимает по одному байту на элемент, массив слов — по два байта, и так далее.

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

; NASM: массив слов по метке my_array, элемент с индексом 2
    mov bx, my_array        ; адрес начала (в flat-модели)
    mov si, 2
    shl si, 1               ; индекс * 2 (размер слова)
    add bx, si
    mov ax, [bx]

Разбор:

  • mov bx, my_array загружает базовый адрес массива в регистр-указатель BX.
  • mov si, 2 устанавливает индекс нужного элемента (третий элемент, если считать с нуля).
  • shl si, 1 умножает индекс на размер элемента в байтах (слово = 2 байта), получая смещение.
  • add bx, si вычисляет эффективный адрес конкретного элемента как base + offset.
  • mov ax, [bx] читает 16-битное значение по вычисленному адресу в регистр AX.
  • Фрагмент иллюстрирует ручную адресацию массива, которая в высокоуровневых языках скрыта за array[i].

Этот пример демонстрирует, что даже сложные структуры данных строятся из простых операций над адресами и блоками памяти.

Структуры и записи​

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

Например, структура, описывающая точку на плоскости с координатами X и Y (по 32 бита каждая), будет занимать 8 байт. Поле X находится по смещению 0, поле Y — по смещению 4. Для доступа к полям используются те же принципы, что и при работе с массивами — через базовый адрес и смещение.

section .data
    point dd 10, 20         ; X=10, Y=20

section .text
    mov ebx, point
    mov eax, [ebx]          ; X
    mov edx, [ebx + 4]      ; Y
    add eax, edx            ; eax = X + Y

Разбор:

  • point dd 10, 20 кладёт два 32-битных поля подряд: смещение 0 и 4.
  • mov ebx, point берёт адрес начала структуры как базу.
  • [ebx] читает первое поле, [ebx + 4] — второе по фиксированному смещению.
  • Для процессора это обычная память; "структура" существует только в голове программиста и в комментариях.
  • Если поменять порядок полей в данных, те же смещения нужно пересчитать в коде.

Некоторые ассемблеры (например, MASM или NASM с макросами) позволяют определять шаблоны структур, чтобы упростить вычисление смещений и повысить читаемость кода. Однако на уровне машинного кода структура остаётся просто блоком памяти.

Упакованные данные и битовые поля​

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

Битовые поля — это части одного байта или слова, выделенные под отдельные флаги или параметры. Например, один байт может содержать восемь логических значений (включено/выключено). Для извлечения или установки конкретного бита используются побитовые операции — AND, OR, XOR, NOT, а также сдвиги (SHL, SHR).

Пример: проверка, установлен ли третий бит в регистре AL:

TEST AL, 00000100b    ; маска для третьего бита
JNZ bit_is_set        ; переход, если бит установлен

Разбор:

  • TEST AL, 00000100b выполняет побитовое AND без сохранения результата, обновляя только флаги процессора.
  • Маска 00000100b оставляет значимым только третий бит регистра AL.
  • Если третий бит был равен 1, результат TEST не нулевой, и ZF сбрасывается.
  • JNZ bit_is_set делает переход именно в случае ZF = 0, то есть когда проверяемый бит установлен.
  • Конструкция полезна для чтения упакованных флагов, где один байт содержит несколько независимых признаков.

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

Представление чисел — порядок байтов​

Один из ключевых аспектов работы с многобайтовыми данными — это порядок байтов (endianness). На архитектурах x86 и x86-64 используется little-endian: младший байт числа хранится по младшему адресу.

Например, 32-битное число 0x12345678 в памяти будет записано как:

Адрес:   N     N+1   N+2   N+3
Байты:  78    56    34    12

Разбор:

  • Таблица показывает little-endian представление: младший байт числа хранится по младшему адресу.
  • Для 0x12345678 байт 0x78 попадает по адресу N, затем идут 0x56, 0x34, 0x12.
  • При чтении как 32-битного значения процессор x86 собирает эти байты обратно в исходное число.
  • При побайтовом анализе дампа памяти порядок выглядит "перевёрнутым", и это штатное поведение архитектуры.
  • Понимание этой раскладки критично для сериализации, сетевых протоколов и ручной отладки памяти.

Это влияет на интерпретацию данных при прямом чтении памяти, при передаче данных между системами с разным порядком байтов, а также при работе с сетевыми протоколами (где обычно используется big-endian). В ассемблере программист должен учитывать этот порядок при работе с многобайтовыми значениями, особенно если данные поступают извне или предназначены для внешних систем.

Работа с текстом — кодировки и завершение строк​

Текст в ассемблере — это массив байтов, каждый из которых соответствует коду символа. Наиболее распространённая кодировка — ASCII, где символы латиницы, цифр и знаков препинания занимают значения от 0 до 127. Расширенные кодировки (например, Windows-1251 или ISO-8859-1) используют старший бит байта для дополнительных символов.

В современных системах всё чаще применяется UTF-8 — переменная кодировка, совместимая с ASCII для базовых символов. В UTF-8 один символ может занимать от 1 до 4 байт. Ассемблер не содержит встроенной поддержки UTF-8, но программист может реализовать обработку таких строк, анализируя байты по правилам кодировки.

Строки в ассемблере обычно завершаются нулевым байтом (0x00), как в языке C. Это позволяет функциям определять конец строки без хранения её длины отдельно. Альтернативный подход — хранение длины в начале строки (как в Pascal), что ускоряет доступ к концу, но требует дополнительного байта.

Данные и исполняемый код — единая природа​

В архитектуре фон Неймана, лежащей в основе большинства современных компьютеров, код и данные хранятся в одной и той же памяти. Это означает, что последовательность байтов, представляющая инструкцию процессора, может быть прочитана как данные, а блок данных — интерпретирован как код.

Такая двойственность лежит в основе многих техник, включая самомодифицирующийся код, JIT-компиляцию и эксплойты переполнения буфера. В ассемблере эта грань особенно тонка — инструкция JMP EAX передаёт управление по адресу, хранящемуся в регистре EAX, независимо от того, содержит ли этот адрес действительно исполняемый код.

Современные операционные системы используют механизмы защиты (например, NX-бит), чтобы запретить исполнение кода из областей памяти, помеченных как "данные". Но на уровне ассемблера эта защита — внешнее ограничение, а не свойство языка.

Связанные статьи для закрепления​

Содержание