Search     or:     and:
 LINUX 
 Language 
 Kernel 
 Package 
 Book 
 Test 
 OS 
 Forum 
 iakovlev.org 
 Languages
 С
 GNU С Library 
 Qt 
 STL 
 Threads 
 C++ 
 Samples 
 stanford.edu 
 ANSI C
 Libs
 LD
 Socket
 Pusher
 Pipes
 Encryption
 Plugin
 Inter-Process
 Errors
 Deep C Secrets
 C + UNIX
 Linked Lists / Trees
 Asm
 Perl
 Python
 Shell
 Erlang
 Go
 Rust
NEWS
Последние статьи :
  Rust 07.11   
  Go 25.12   
  EXT4 10.11   
  FS benchmark 15.09   
  Сетунь 23.07   
  Trees 25.06   
  Apache 03.02   
  SQL 30.07   
  JFS 10.06   
  B-trees 01.06   
 
TOP 20
 P.Collins...1342 
 Steve Pate 1...791 
 QT->Qt3...509 
 Trees...433 
 Python...357 
 Steve Pate 3...340 
 TCP 2...316 
 Rodriguez 6...293 
 Rubni-Corbet -> Глав...291 
 Максвелл 3...290 
 TCP 3...289 
 Daniel Bovet 4...289 
 Mod_perl 2...279 
 Linux Inline Assembly...279 
 MySQL & PosgreSQL...273 
 Robert Love 2...265 
 UML 3...264 
 Rodriguez 2...264 
 Стивенс 6...262 
 Daniel Bovet 3...260 
 
  01.05.2017 : 2190164 посещений 

iakovlev.org
ДОС-вариант

Процессоры Intel в реальном режиме

Процессор Intel x86 после включения питания оказывается в так называемом режиме реальной адресации памяти, или просто реальном режиме. Большинство операционных систем сразу же переводят его в защищенный режим, позволяющий им обеспечивать многозадачность, распределение памяти и другие функции. Пользовательские программы в таких операционных системах часто работают еще в одном режиме, режиме V86, из которого им доступно все то же, что и из реального, кроме команд, относящихся к управлению защищенным режимом. Таким образом, эта глава описывает не только реальный режим, но и V86, то есть все то, что доступно программисту, если он не проектирует операционную систему или DPMI-сервер, в подавляющем большинстве случаев.

Регистры процессора

Начиная с 80386, процессоры Intel предоставляют 16 основных регистров для пользовательских программ плюс еще 11 регистров для работы с числами с плавающей запятой (FPU/NPX) и мультимедийными приложениями (MMX). Все команды так или иначе изменяют значения регистров, и всегда быстрее и удобнее обращаться к регистру, чем к памяти. Помимо основных регистров из реального (но не из виртуального) режима доступны также регистры управления памятью (GDTR, IDTR, TR, LDTR) регистры управления (CR0, CR1 – CR4), отладочные регистры (DR0 – DR7) и машинно-специфичные регистры, но они не применяются для повседневных задач и будут рассматриваться в соответствующих главах позже.

Регистры общего назначения

32-битные регистры EAX (аккумулятор), EBX (база), ECX (счетчик), EDX (регистр данных) могут использоваться без ограничений для любых целей — временного хранения данных, аргументов или результатов различных операций. Названия этих регистров происходят от того, что некоторые команды применяют их специальным образом: так, аккумулятор часто используется для хранения результата действий, выполняемых над двумя операндами, регистр данных в этих случаях получает старшую часть результата, если он не умещается в аккумулятор, регистр-счетчик используется как счетчик в циклах и строковых операциях, а регистр-база используется при так называемой адресации по базе. Младшие 16 бит каждого из этих регистров могут использоваться как самостоятельные регистры и имеют имена (соответственно AX, BX, CX, DX). На самом деле в процессорах 8086 – 80286 все регистры имели размер 16 бит и назывались именно так, а 32-битные EAX – EDX появились с введением 32-битной архитектуры в 80386. Кроме этого, отдельные байты в 16-битных регистрах AX – DX тоже имеют свои имена и могут использоваться как 8-битные регистры. Старшие байты этих регистров называются AH, BH, CH, DH, а младшие — AL, BL, CL, DL (рис. 3).

Другие четыре регистра общего назначения — ESI (индекс источника), EDI (индекс приемника), EBP (указатель базы), ESP (указатель стека) — имеют более конкретное назначение и могут применяться для хранения всевозможных временных переменных, только когда они не используются по назначению. Регистры ESI и EDI используются в строковых операциях, EBP и ESP используются при работе со стеком (см. параграф 2.1.3). Так же, как и с регистрами EAX – EDX, младшие половины этих четырех регистров называются SI, DI, BP и SP соответственно, и в процессорах до 80386 только они и присутствовали.

Сегментные регистры

При использовании каждой из сегментированных моделей памяти для формирования любого адреса применяются два числа — адрес начала сегмента и смещение искомого байта относительно этого начала (в бессегментной модели памяти flat адреса начал всех сегментов равны). Операционные системы (кроме DOS) могут размещать сегменты, с которыми работает программа пользователя, в разных местах в памяти, и даже могут временно записывать их на диск, если памяти не хватает. Так как сегменты могут оказаться где угодно, программа обращается к ним, используя вместо настоящего адреса начала сегмента 16-битное число, называемое селектором. В процессорах Intel предусмотрено шесть шестнадцатибитных регистров — CS, DS, ES, FS, GS, SS, используемых для хранения селекторов. (Регистры FS и GS отсутствовали в 8086, но появились уже в 80286.) Это не значит, что программа не может одновременно работать с большим количеством сегментов памяти, — в любой момент времени можно изменить значения, записанные в этих регистрах.

В отличие от регистров DS, ES, GS, FS, которые называются регистрами сегментов данных, регистры CS и SS отвечают за сегменты двух особенных типов — сегмент кода и сегмент стека. Сегмент кода содержит программу, исполняющуюся в данный момент, так что запись нового селектора в этот регистр приводит к тому, что далее будет исполнена не следующая по тексту программы команда, а команда из кода, находящегося в другом сегменте, с тем же смещением. Смещение следующей выполняемой команды всегда хранится в специальном регистре — EIP (указатель инструкции, шестнадцатибитная форма IP), запись в который также приведет к тому, что следующей будет исполнена какая-нибудь другая команда. На самом деле все команды передачи управления — перехода, условного перехода, цикла, вызова подпрограммы и т.п. — и осуществляют эту самую запись в CS и EIP.

Стек

Стек — это специальным образом организованный участок памяти, используемый для временного хранения переменных, для передачи параметров вызываемым подпрограммам и для сохранения адреса возврата при вызове процедур и прерываний. Легче всего представить стек в виде стопки листов бумаги (это одно из значений слова «stack» в английском языке) — вы можете класть и забирать листы бумаги только с вершины стопки. Таким образом, если записать в стек числа 1, 2, 3, то при чтении они будут получаться в обратном порядке — 3, 2, 1. Стек располагается в сегменте памяти, описываемом регистром SS, а текущее смещение вершины стека записано в регистре ESP, причем при записи в стек значение этого смещения уменьшается, то есть стек растет вниз от максимально возможного адреса (рис. 4). Такое расположение стека «вверх ногами» может быть необходимо, например в бессегментной модели памяти, когда все сегменты, включая сегмент стека и сегмент кода, занимают одну и ту же область — всю память. Тогда программа исполняется в нижней области памяти, в области малых адресов, и EIP растет, а стек располагается в верхней области памяти, и ESP уменьшается.

При вызове подпрограммы параметры в большинстве случаев помещают в стек, а в EBP записывают текущее значение ESP. Тогда, если подпрограмма использует стек для хранения локальных переменных, ESP изменится, но EBP можно будет использовать для того, чтобы считывать значения параметров напрямую из стека (их смещения будут записываться как EBP + номер параметра). Более подробно вызовы подпрограмм и все возможные способы передачи параметров рассмотрены в главе

Регистр флагов

Еще один важный регистр, использующийся при выполнении большинства команд, — регистр флагов EFLAGS. Как и раньше, его младшие 16 бит, представлявшие из себя весь этот регистр до 80386, называются FLAGS. В этом регистре каждый бит является флагом, то есть устанавливается в 1 при определенных условиях или установка его в 1 изменяет поведение процессора. Все флаги, расположенные в старшем слове регистра EFLAGS, имеют отношение к управлению защищенным режимом, поэтому здесь рассмотрен только регистр FLAGS (рис. 5).

 CF — флаг переноса. 
 Устанавливается в 1, если результат предыдущей операции не уместился 
 в приемнике и произошел перенос из старшего бита или если требуется 
 заем (при вычитании), иначе устанавливается в 0. 
 Например, после сложения слова 0FFFFh и 1, если регистр, 
 в который надо поместить результат, — слово, в него будет записано 0000h и флаг CF = 1.
  
 PF — флаг четности. 
 Устанавливается в 1, если младший байт результата предыдущей команды 
 содержит четное число бит, равных 1; устанавливается в 0, 
 если число единичных бит нечетное. (Это не то же самое, что делимость на два. 
 Число делится на два без остатка, если его самый младший бит равен нулю, 
 и не делится, если он равен 1.)
  
 AF — флаг полупереноса или вспомогательного переноса. 
 Устанавливается в 1, если в результате предыдущей операции произошел перенос 
 (или заем) из третьего бита в четвертый. 
 Этот флаг используется автоматически командами двоично-десятичной коррекции.
  
 ZF — флаг нуля. 
 Устанавливается в 1, если результат предыдущей команды — ноль.
  
 SF — флаг знака. 
 Этот флаг всегда равен старшему биту результата.
  
 TF — флаг ловушки. 
 Этот флаг был предусмотрен для работы отладчиков, не использующих защищенный режим. 
 Установка его в 1 приводит к тому, что после выполнения каждой команды программы 
 управление временно передается отладчику (вызывается прерывание 1 — см. 
 описание команды INT).
  
 IF — флаг прерываний. 
 Установка этого флага в 1 приводит к тому, что процессор перестает обрабатывать 
 прерывания от внешних устройств (см. описание команды INT). 
 Обычно его устанавливают на короткое время для выполнения критических участков кода.
  
 DF — флаг направления. 
 Этот флаг контроллирует поведение команд обработки строк — 
 когда он установлен в 1, строки обрабатываются в сторону уменьшения адресов, 
 а когда DF = 0 — наоборот.
  
 OF — флаг переполнения. 
 Этот флаг устанавливается в 1, если результат предыдущей арифметической операции 
 над числами со знаком выходит за допустимые для них пределы. 
 Например, если при сложении двух положительных чисел получается число 
 со старшим битом, равным единице (то есть отрицательное) и наоборот.
  
 Флаги IOPL (уровень привелегий ввода-вывода) и NT (вложенная задача) применяются 
 в защищенном режиме.
 

Прямая адресация

Если известен адрес операнда, располагающегося в памяти, можно использовать этот адрес. Если операнд — слово, находящееся в сегменте, на который указывает ES, со смещением от начала сегмента 0001, то команда

      mov     ax,es:0001
 
поместит это слово в регистр AX. В реальных программах обычно для задания статических переменных используют директивы определения данных (глава 3.3), которые позволяют ссылаться на статические переменные не по адресу, а по имени. Тогда, если в сегменте, указанном в ES, была описана переменная word_var размером в слово, можно записать ту же команду как
     mov     ax,es:word_var
 
В таком случае ассемблер сам заменит слово «word_var» на соответствующий адрес. Если селектор сегмента данных находится в DS, имя сегментного регистра при прямой адресации можно не указывать, DS используется по умолчанию. Прямая адресация иногда называется адресацией по смещению.

Адресация отличается для реального и защищенного режимов. В реальном режиме (так же как и в режиме V86) смещение всегда 16-битное, это значит, что ни непосредственно указанное смещение, ни результат сложения содержимого разных регистров в более сложных методах адресации не могут превышать границ слова. При программировании для Windows, для DOS4G, PMODE и в других ситуациях, когда программа будет запускаться в защищенном режиме, смещение не может превышать границ двойного слова.

Косвенная адресация

По аналогии с регистровыми и непосредственными операндами адрес операнда в памяти также можно не указывать непосредственно, а хранить в любом регистре. До 80386 для этого можно было использовать только BX, SI, DI и BP, но потом эти ограничения были сняты и адрес операнда разрешили считывать также и из EAX, EBX, ECX, EDX, ESI, EDI, EBP и ESP (но не из AX, CX, DX или SP напрямую — надо использовать EAX, ECX, EDX, ESP соответственно или предварительно скопировать смещение в BX, SI, DI или BP). Например, следующая команда помещает в регистр AX слово из ячейки памяти, селектор сегмента которой находится в DS, а смещение — в BX:

 
     mov     ax,[bx]
 
Как и в случае прямой адресации, DS используется по умолчанию, но не во всех случаях: если смещение берут из регистров ESP, EBP или BP, то в качестве сегментного регистра используется SS. В реальном режиме можно свободно пользоваться всеми 32-битными регистрами, надо только следить, чтобы их содержимое не превышало границ 16-битного слова.

Адресация по базе со сдвигом

Теперь скомбинируем два предыдущих метода адресации: следующая команда

     mov     ax,[bx+2]
 
помещает в регистр AX слово, находящееся в сегменте, указанном в DS, со смещением на 2 большим, чем число, находящееся в BX. Так как слово занимает ровно два байта, эта команда поместила в AX слово, непосредственно следующее за тем, которое есть в предыдущем примере. Такая форма адресации используется в тех случаях, когда в регистре находится адрес начала структуры данных, а доступ надо осуществить к какому-нибудь элементу этой структуры. Другое важное применение адресации по базе со сдвигом — доступ из подпрограммы к параметрам, переданным в стеке, используя регистр BP (EBP) в качестве базы и номер параметра в качестве смещения, что детально разобрано в параграфе 5.2. Другие допустимые формы записи этого способа адресации:
     mov     ax,[bp]+2
     mov     ax,2[bp]
 
До 80386 в качестве базового регистра можно было использовать только BX, BP, SI или DI и сдвиг мог быть только байтом или словом (со знаком). Начиная с 80386 и старше, процессоры Intel позволяют дополнительно использовать EAX, EBX, ECX, EDX, EBP, ESP, ESI и EDI, так же как и для обычной косвенной адресации. С помощью этого метода можно организовывать доступ к одномерным массивам байт: смещение соответствует адресу начала массива, а число в регистре — индексу элемента массива, который надо считать. Очевидно, что, если массив состоит не из байт, а из слов, придется умножать базовый регистр на два, а если из двойных слов — на четыре. Для этого предусмотрен следующий специальный метод адресации.

Косвенная адресация с масштабированием

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

     mov     ax,[esi*2]+2
 
Множитель, который может быть равен 1, 2, 4 или 8, соответствует размеру элемента массива — байту, слову, двойному слову, учетверенному слову соответственно. Из регистров в этом варианте адресации можно использовать только EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP, но не SI, DI, BP или SP, которые можно было использовать в предыдущих вариантах.

Адресация по базе с индексированием

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

      mov     ax,[bx+si+2]
     mov     ax,[bx][si]+2
     mov     ax,[bx+2][si]
     mov     ax,[bx][si+2]
     mov     ax,2[bx][si]
 
В регистр AX помещается слово из ячейки памяти со смещением, равным сумме чисел, содержащихся в BX и SI, и числа 2. Из шестнадцатибитных регистров так можно складывать только BX + SI, BX + DI, BP + SI и BP + DI, а из 32-битных — все восемь регистров общего назначения. Так же как и для прямой адресации, вместо непосредственного указания числа можно использовать имя переменной, заданной одной из директив определения данных. Так можно прочитать, например, число из двумерного массива: если задана таблица 10x10 байт, 2 — смещение ее начала от начала сегмента данных (на практике будет использоваться имя этой таблицы), BX = 20, а SI = 7, приведенные команды прочитают слово, состоящее из седьмого и восьмого байт третьей строки. Если таблица состоит не из одиночных байт, а из слов или двойных слов, удобнее использовать следующую, наиболее полную форму адресации.

Пересылка данных

 Команда:
 MOV приемник, источник
 
 
 Назначение:
 Пересылка данных
 
 
 Процессор:
 8086
 
Базовая команда пересылки данных. Копирует содержимое источника в приемник, источник не изменяется. Команда MOV действует аналогично операторам присваивания из языков высокого уровня, то есть команда
     mov      ax,bx
 
 эквивалентна выражению
 
  
     ах := bх;
 
 
 языка Паскаль или
 
  
     ах = bх;
 
 
языка С, за исключением того, что команда ассемблера позволяет работать не только с переменными в памяти, но и со всеми регистрами процессора.

В качестве источника для MOV могут использоваться: число (непосредственный операнд), регистр общего назначения, сегментный регистр или переменная (то есть операнд, находящийся в памяти). В качестве приемника — регистр общего назначения, сегментный регистр (кроме CS) или переменная. Оба операнда должны быть одного и того же размера — байт, слово или двойное слово.

Нельзя выполнять пересылку данных с помощью MOV из одной переменной в другую, из одного сегментного регистра в другой и нельзя помещать в сегментный регистр непосредственный операнд — эти операции выполняют двумя командами MOV (из сегментного регистра в обычный и уже из него в другой сегментный) или парой команд PUSH/POP.

Загрузка регистра SS командой MOV автоматически запрещает прерывания до окончания следующей за этим команды MOV, так что можно загрузить SS и ESP двумя последовательными командами MOV, не опасаясь, что в этот момент произойдет прерывание, обработчик которого получит неправильный стек. В любом случае для загрузки значения в регистр SS предпочтительнее команда LSS.

 Команда:
 CMOVcc приемник, источник
 
 
 Назначение:
 Условная пересылка данных
 
 
 Процессор:
 P6
 
Это набор команд, которые копируют содержимое источника в приемник, если удовлетворяется то или иное условие (см. табл. 5). Источником может быть регистр общего назначения или переменная, а приемником — только регистр. Условие, которое должно удовлетворяться, — просто равенство нулю или единице тех или иных флагов из регистра FLAGS, но, если использовать команды CMOVcc сразу после команды СМР (сравнение) с теми же операндами, условия приобретают особый смысл, например:
     cmp      ах,bх     ; сравнить ах и bх
     cmovl    ax,bx     ; если ах < bх, скопировать bх в ах
 
Слова «выше» и «ниже» в таблице 5 относятся к сравнению чисел без знака, слова «больше» и «меньше» учитывают знак.
 
 Команда:
 XCHG операнд1, операнд2
 
 
 Назначение:
 Обмен операндов между собой
 
 
 Процессор:
 8086
 
Содержимое операнда 2 копируется в операнд 1, а старое содержимое операнда 1 — в операнд 2. XCHG можно выполнять над двумя регистрами или над регистром и переменной.
 
  
     xchg     eax,ebx    ; то же, что три команды на языке С:
                         ; temp = eax; eax = ebx; ebx = temp;
     xchg     al,al      ; а эта команда не делает ничего
 
  
 
 Команда:
 BSWAP регистр32
 
 
 Назначение:
 Обмен байт внутри регистра
 
 
 Процессор:
 80486
 
Обращает порядок байт в 32-битном регистре. Биты 0 – 7 (младший байт младшего слова) меняются местами с битами 24 – 31 (старший байт старшего слова), а биты 8 – 15 (старший байт младшего слова) меняются местами с битами 16 – 23 (младший байт старшего слова).
 
  
     mov      eax,12345678h
     bswap    eax       ; теперь в еах находится 78563412h
 
 
Чтобы обратить порядок байт в 16-битном регистре, следует использовать команду XCHG:
 
     xchg     al,ah     ; обратить порядок байт в АХ
 
В процессорах Intel команду BSWAP можно использовать и для обращения порядка байт в 16-битных регистрах, но в некоторых совместимых процессорах других фирм этот вариант BSWAP не реализован.
 Команда:
 PUSH источник
 
 
 Назначение:
 Поместить данные в стек
 
 
 Процессор:
 8086
 
Помещает содержимое источника в стек. Источником может быть регистр, сегментный регистр, непосредственный операнд или переменная. Фактически эта команда копирует содержимое источника в память по адресу SS:[ESP] и уменьшает ESP на размер источника в байтах (2 или 4). Команда PUSH практически всегда используется в паре с POP (считать данные из стека). Так, например, чтобы скопировать содержимое одного сегментного регистра в другой (что нельзя выполнить одной командой MOV), можно использовать такую последовательность команд:
     push     cs
     pop      ds    ; теперь DS указывает на тот же сегмент, что и CS
 
Другое частое применение команд PUSH/POP — временное хранение переменных, например:
     push     eax   ; сохраняет текущее значение ЕАХ
     ...            ; здесь располагаются какие-нибудь команды,
                    ; которые используют ЕАХ, например CMPXCHG
     pop      eax   ; восстанавливает старое значение ЕАХ
 
Начиная с 80286, команда PUSH ESP (или SP) помещает в стек значение ESP до того, как эта же команда его уменьшит, в то время как на 8086 SP помещался в стек уже уменьшенным на два.
  Команда:
 POP приемник
 
 
 Назначение:
 Считать данные из стека
 
 
 Процессор:
 8086
 
Помещает в приемник слово или двойное слово, находящееся в вершине стека, увеличивая ESP на 2 или 4 соответственно. POP выполняет действие, полностью обратное PUSH. Приемником может быть регистр общего назначения, сегментный регистр, кроме CS (чтобы загрузить CS из стека, надо воспользоваться командой RET), или переменная. Если в роли приемника выступает операнд, использующий ESP для косвенной адресации, команда POP вычисляет адрес операнда уже после того, как она увеличивает ESP.
 Команда:
 PUSHA
 PUSHAD
 
 
 Назначение:
 Поместить в стек все регистры общего назначения
 
 
 Процессор:
 80186
 80386
 
PUSHA помещает в стек регистры в следующем порядке: АХ, СХ, DX, ВХ, SP, ВР, SI и DI. PUSHAD помещает в стек ЕАХ, ЕСХ, EDX, ЕВХ, ESP, EBP, ESI и EDI. (В случае SP и ESP используется значение, которое находилось в этом регистре до начала работы команды.) В паре с командами POPA/POPAD, считывающими эти же регистры из стека в обратном порядке, это позволяет писать подпрограммы (обычно обработчики прерываний), которые не должны изменять значения регистров по окончании своей работы. В начале такой подпрограммы вызывают команду PUSHA, а в конце — РОРА.

На самом деле PUSHA и PUSHAD — одна и та же команда с кодом 60h. Ее поведение определяется тем, выполняется ли она в 16- или в 32-битном режиме. Если программист использует команду PUSHAD в 16-битном сегменте или PUSHA в 32-битном, ассемблер просто записывает перед ней префикс изменения размерности операнда (66h).

Это же будет распространяться на некоторые другие пары команд: РОРА/POPAD, POPF/POPFD, PUSHF/PUSHFD, JCXZ/JECXZ, CMPSW/CMPSD, INSW/INSD, LODSW/LODSD, MOVSW/MOVSD, OUTSW/OUTSD, SCASW/SCASD и STOSW/STOSD.

 Команда:
 POPA
 POPAD
 
 
 Назначение:
 Загрузить из стека все регистры общего назначения
 
 
 Процессор:
 80186
 80386
 
Эти команды выполняют действия, полностью обратные действиям PUSHA и PUSHAD, за исключением того, что помещенное в стек значение SP или ESP игнорируется. РОРА загружает из стека DI, SI, BP, увеличивает SP на два, загружает ВХ, DX, CX, AX, a POPAD загружает EDI, ESI, ЕВР, увеличивает ESP на 4 и загружает ЕВХ, EDX, ЕСХ, ЕАХ.
 Команда:
 IN приемник, источник
 
 
 Назначение:
 Считать данные из порта
 
 
 Процессор:
 8086
 
Копирует число из порта ввода-вывода, номер которого указан в источнике, в приемник. Приемником может быть только AL, АХ или ЕАХ. Источник — или непосредственный операнд, или DX, причем можно указывать только номера портов не больше 255.
 Команда:
 OUT приемник, источник
 
 
 Назначение:
 Записать данные в порт
 
 
 Процессор:
 8086
 
Копирует число из источника (AL, АХ или ЕАХ) в порт ввода-вывода, номер которого указан в приемнике. Приемник может быть либо непосредственным номером порта, либо регистром DX. На командах IN и OUT строится все общение процессора с устройствами ввода-вывода — клавиатурой, жесткими дисками, различными контроллерами, и используются они, в первую очередь, в драйверах устройств. Например, чтобы включить динамик PC, достаточно выполнить команды:
 
     in       al,61h
     or       al,3
     out      61h,al
 
 
 Программирование портов ввода-вывода рассмотрено подробно в главе 5.10.
 
  
 
 Команда:
 CWD
 
 
 Назначение:
 Конвертирование слова в двойное слово
 
 
 Процессор:
 8086
 
 
 Команда:
 CDQ
 
 
 Назначение:
 Конвертирование двойного слова в учетверенное
 
 
 Процессор:
 80386
 
Команда CWD превращает слово в AХ в двойное слово, младшая половина которого (биты 0 – 15) остается в АХ, а старшая (биты 16 – 31) располагается в DX. Команда CDQ выполняет аналогичное действие по отношению к двойному слову в ЕАХ, расширяя его до учетверенного слова в EDX:EAX. Эти команды всего лишь устанавливают все биты регистра DX или EDX в значение, равное значению старшего бита регистра АХ или ЕАХ, сохраняя таким образом его знак.
 Команда:
 CBW
 
 
 Назначение:
 Конвертирование байта в слово
 
 
 Процессор:
 8086
 
 
 Команда:
 CWDE
 
 
 Назначение:
 Конвертирование слова в двойное слово
 
 
 Процессор:
 80386
 
CBW расширяет байт, находящийся в регистре AL, до слова в АХ, CWDE расширяет слово в АХ до двойного слова в ЕАХ. CWDE и CWD отличаются тем, что CWDE располагает свой результат в ЕАХ, в то время как CWD, команда, выполняющая точно такое же действие, располагает результат в паре регистров DX:AX. Так же как и команды CWD/CDQ, расширение выполняется путем установки каждого бита старшей половины результата равным старшему биту исходного байта или слова, то есть:
 
     mov      al,0F5h   ; AL = 0F5h = 245 = -11
     cbw                ; теперь АХ = 0FFF5h = 65 525 = -11
 
Так же как и в случае с командами PUSHA/PUSHAD, пара команд CWD/CDQ — это одна команда с кодом 99h, и пара команд CBW/CWDE — одна команда с кодом 98h. Интерпретация этих команд зависит от того, в каком (16-битном или в 32-битном) сегменте они исполняются, и точно так же, если указать CDQ или CWDE в 16-битном сегменте, ассемблер поставит префикс изменения разрядности операнда.
 Команда:
 MOWSX приемник, источник
 
 
 Назначение:
 Пересылка с расширением знака
 
 
 Процессор:
 80386
 
Копирует содержимое источника (регистр или переменная размером в байт или слово) в приемник (16- или 32-битный регистр) и расширяет знак аналогично командам CBW/CWDE.
 Команда:
 MOWZX приемник, источник
 
 
 Назначение:
 Пересылка с расширением нулями
 
 
 Процессор:
 80386
 
Копирует содержимое источника (регистр или переменная размером в байт или слово) в приемник (16- или 32-битный регистр) и расширяет нулями, то есть команда
      movzx   ax,bl
 эквивалентна паре команд
 
  
     mov     al,bl
     mov     ah,0
 
  
 
 Команда:
 XLAT адрес
 XLATB
 
 
 Назначение:
 Трансляция в соответствии с таблицей
 
 
 Процессор:
 8086
 
Помещает в AL байт из таблицы в памяти по адресу ES:BX (или ES:EBX) со смещением относительно начала таблицы, равным AL. В качестве аргумента для XLAT в ассемблере можно указать имя таблицы, но эта информация никак не используется процессором и служит только как комментарий. Если этот комментарий не нужен, можно применить форму записи XLATB. В качестве примера использования XLAT можно написать следующий вариант преобразования шестнадцатеричного числа в ASCII-код соответствующего ему символа:
     mov      al,0Ch
     mov      bx, offset htable
     xlatb
 
 
 если в сегменте данных, на который указывает регистр ES, было записано
 
  
     htable   db     "0123456789ABCDEF"
 
то теперь AL содержит не число 0Сh, а ASCII-код буквы «С». Разумеется, это преобразование можно выполнить, используя гораздо более компактный код всего из трех арифметических команд, который будет рассмотрен в описании команды DAS, но с XLAT можно выполнять любые преобразования такого рода.
 Команда:
 LEA приемник, источник
 
 
 Назначение:
 Вычисление эффективного адреса
 
 
 Процессор:
 8086
 
Вычисляет эффективный адрес источника (переменная) и помещает его в приемник (регистр). С помощью LEA можно вычислить адрес переменной, которая описана сложным методом адресации, например по базе с индексированием. Если адрес 32-битный, а регистр-приемник 16-битный, старшая половина вычисленного адреса теряется, если наоборот, приемник 32-битный, а адресация 16-битная, то вычисленное смещение дополняется нулями.

Двоичная арифметика

Все команды из этого раздела, кроме команд деления и умножения, изменяют флаги OF, SF, ZF, AF, CF, PF в соответствии с назначением каждого из этих флагов (см. главу 2.1.4).
  Команда:
 ADD приемник, источник
 
 
 Назначение:
 Сложение
 
 
 Процессор:
 8086
 
Команда выполняет арифметическое сложение приемника и источника, помещает сумму в приемник, не изменяя содержимое источника. Приемник может быть регистром или переменной, источник может быть числом, регистром или переменной, но нельзя использовать переменную одновременно и для источника, и для приемника. Команда ADD никак не различает числа со знаком и без знака, но, употребляя значения флагов CF (перенос при сложении чисел без знака), OF (перенос при сложении чисел со знаком) и SF (знак результата), можно использовать ее и для тех, и для других.
 Команда:
 ADC приемник, источник
 
 Назначение:
 Сложение с переносом
 
Эта команда во всем аналогична ADD, кроме того, что она выполняет арифметическое сложение приемника, источника и флага СF. Пара команд ADD/ADC используется для сложения чисел повышенной точности. Сложим, например, два 64-битных целых числа: пусть одно из них находится в паре регистров EDX:EAX (младшее двойное слово (биты 0 – 31) — в ЕАХ и старшее (биты 32 – 63) — в EDX), а другое — в паре регистров ЕВХ:ЕСХ:
     add      eax,ecx
     adc      edx,ebx
 
Если при сложении младших двойных слов произошел перенос из старшего разряда (флаг CF = 1), то он будет учтен следующей командой ADC.
 Команда:
 XADD приемник, источник
 
 
 Назначение:
 Обменять между собой и сложить
 
Выполняет сложение, помещает содержимое приемника в источник, — сумму операндов — в приемник. Источник всегда регистр, приемник может быть регистром и переменной.
 Команда:
 SUB приемник, источник
 
 
 Назначение:
 Вычитание
 
 
 Процессор:
 8086
 
Вычитает источник из приемника и помещает разность в приемник. Приемник может быть регистром или переменной, источник может быть числом, регистром или переменной, но нельзя использовать переменную одновременно и для источника, и для приемника. Точно так же, как и команда ADD, SUB не делает различий между числами со знаком и без знака, но флаги позволяют использовать ее как для тех, так и для других.
 Команда:
 SBB приемник, источник
 
 
 Назначение:
 Вычитание с займом
 
 
 Процессор:
 8086
 
Эта команда во всем аналогична SUB, кроме того, что она вычитает из приемника значение источника и дополнительно вычитает значение флага CF. Так, можно использовать эту команду для вычитания 64-битных чисел в EDX:EAX и ЕВХ:ЕСХ аналогично ADD/ADC:
     sub      eax,ecx
     sbb      edx,ebx
 
Если при вычитании младших двойных слов произошел заем, то он будет учтен при вычитании старших.
 Команда:
 IMUL источник
 IMUL приемник, источник
 IMUL приемник, источник1, источник2
 
 Назначение:
 Умножение чисел со знаком
 
 Процессор:
 8086
 80386
 80186
 
Эта команда имеет три формы, различающиеся числом операндов:

IMUL источник: источник (регистр или переменная) умножается на AL, АХ или ЕАХ (в зависимости от размера операнда), и результат располагается в АХ, DX:AX или EDX:EAX соответственно.

IMUL приемник,источник: источник (число, регистр или переменная) умножается на приемник (регистр), и результат заносится в приемник.

IMUL приемник,источник1,источник2: источник 1 (регистр или переменная) умножается на источник 2 (число), и результат заносится в приемник (регистр).

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

 Значения флагов SF, ZF, AF и PF после команды IMUL не определены.
 
 Команда:
 MUL источник
 
 Назначение:
 Умножение чисел без знака
 
Выполняет умножение содержимого источника (регистр или переменная) и регистра AL, АХ, ЕАХ (в зависимости от размера источника) и помещает результат в АХ, DX:AX, EDX:EAX соответственно. Если старшая половина результата (АН, DX, EDX) содержит только нули (результат целиком поместился в младшую половину), флаги CF и OF устанавливаются в 0, иначе — в 1. Значение остальных флагов (SF, ZF, AF и PF) не определено.
 Команда:
 IDIV источник
 
 
 Назначение:
 Целочисленное деление со знаком
 
 
 Процессор:
 8086
 
Выполняет целочисленное деление со знаком AL, АХ или ЕАХ (в зависимости от размера источника) на источник (регистр или переменная) и помещает результат в AL, АХ или ЕАХ, а остаток — в АН, DX или EDX соответственно. Результат всегда округляется в сторону нуля, знак остатка всегда совпадает со знаком делимого, абсолютное значение остатка всегда меньше абсолютного значения делителя. Значения флагов CF, OF, SF, ZF, AF и PF после этой команды не определены, а переполнение или деление на ноль вызывает исключение #DE (ошибка при делении) в защищенном режиме и прерывание 0 — в реальном.
 Команда:
 DIV источник
 
 
 Назначение:
 Целочисленное деление без знака
 
Выполняет целочисленное деление без знака AL, АХ или ЕАХ (в зависимости от размера источника) на источник (регистр или переменная) и помещает результат в AL, АХ или ЕАХ, а остаток — в АН, DX или EDX соответственно. Результат всегда округляется в сторону нуля, абсолютное значение остатка всегда меньше абсолютного значения делителя. Значения флагов CF, OF, SF, ZF, AF и PF после этой команды не определены, а переполнение или деление на ноль вызывает исключение #DE (ошибка при делении) в защищенном режиме и прерывание 0 — в реальном.
 Команда:
 INC приемник
 
 
 Назначение:
 Инкремент
 
 
 Процессор:
 8086
 
Увеличивает приемник (регистр или переменная) на 1. Единственное отличие этой команды от ADD приемник,1 состоит в том, что флаг CF не затрагивается. Остальные арифметические флаги (OF, SF, ZF, AF, PF) устанавливаются в соответствии с результатом сложения.
 Команда:
 DEC приемник
 
 
 Назначение:
 Декремент
 
Уменьшает приемник (регистр или переменная) на 1. Единственное отличие этой команды от SUB приемник,1 состоит в том, что флаг CF не затрагивается. Остальные арифметические флаги (OF, SF, ZF, AF, PF) устанавливаются в соответствии с результатом вычитания.
 Команда:
 NEG приемник
 
 
 Назначение:
 Изменение знака
 
 
Выполняет над числом, содержащимся в приемнике (регистр или переменная), операцию дополнения до двух. Эта операция эквивалентна обращению знака операнда, если рассматривать его как число со знаком. Если приемник равен нулю, флаг CF устанавливается в 0, иначе — в 1. Остальные флаги (OF, SF, ZF, AF, PF) устанавливаются в соответствии с результатом операции.

Красивый пример применения команды NEG — получение абсолютного значения числа, используя всего две команды — изменение знака и переход на первую команду еще раз, если знак отрицательный:

 
     label0:   neg      eax
               js       label0
 
 
 
 
 
 Команда:
 CMP приемник, источник
 
 
 Назначение:
 Сравнение
 
 
Сравнивает приемник и источник и устанавливает флаги. Сравнение осуществляется путем вычитания источника (число, регистр или переменная) из приемника (регистр или переменная; приемник и источник не могут быть переменными одновременно), причем результат вычитания никуда не записывается, единственным результатом работы этой команды оказывается изменение флагов CF, OF, SF, ZF, AF и PF. Обычно команду СМР используют вместе с командами условного перехода (Jcc), условной пересылки данных (CMOVcc) или условной установки байт (SETcc), которые позволяют использовать результат сравнения, не обращая внимания на детальное значение каждого флага. Так, команды CMOVE, JE и SETE выполнят соответствующие действия, если значения операндов предшествующей команды СМР были равны.

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

     test     ax,ax
 
 
 а равенство единице — однобайтной командой
 
  
     dec      ax
 
 
 
 
 
 Команда:
 CMPXCHG приемник, источник
 
 
 Назначение:
 Сравнить и обменять между собой
 
 
Сравнивает значение, содержащееся в AL, АХ, ЕАХ (в зависимости от размера операндов), с приемником (регистром). Если они равны, содержимое источника копируется в приемник и флаг ZF устанавливается в 1. Если они не равны, содержимое приемника копируется в AL, АХ, ЕАХ и флаг ZF устанавливается в 0. Остальные флаги устанавливаются по результату операции сравнения, как после СМР. Источник всегда регистр, приемник может быть регистром и переменной.
 Команда:
 CMPXCHG8B приемник
 
 
 Назначение:
 Сравнить и обменять восемь байт
 
 
 Процессор:
 Р5
 
Выполняет сравнение содержимого регистров EDX:EAX как 64-битного числа (младшее двойное слово в ЕАХ, старшее — в EDX) с приемником (восьмибайтная переменная в памяти). Если они равны, содержимое регистров ЕСХ:ЕВХ как 64-битное число (младшее двойное слово в ЕВХ, старшее — в ЕСХ) копируется в приемник. Иначе содержимое приемника копируется в EDX:EAX.

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

     lea      bx,[ebx+ebx*4]  ; ВХ=ЕВХ*5
 или сложения:
 
     lea      ebx,[eax+12]    ; ЕВХ=ЕАХ+12
 
 
 (эти команды меньше, чем соответствующие MOV и ADD, и не изменяют флаги) 
 

Десятичная арифметика

Процессоры Intel поддерживают операции с двумя форматами десятичных чисел: неупакованное двоично-десятичное число — байт, принимающий значения от 00 до 09, и упакованное двоично-десятичное число — байт, принимающий значения от 00 до 99h. Все обычные арифметическиe операции над такими числами приводят к неправильным результатам. Например, если увеличить 19h на 1, то получится число 1Ah, а не 20h. Для коррекции результатов арифметических действий над двоично-десятичными числами используются следующие команды.
 Команда:
 DAA
 
 
 Назначение:
 BCD-коррекция после сложения
 
 
Если эта команда выполняется сразу после ADD (ADC, INC или XADD) и в регистре AL находится сумма двух упакованных двоично-десятичных чисел, то в результате в AL записывается упакованное двоично-десятичное число, которое должно было быть результатом сложения. Например, если AL содержит число 19h, последовательность команд
 
     inc      al
     daa
 
 
 приведет к тому, что в AL окажется 20h (а не 1Ah, как было бы после INC).
 
 DAA выполняет следующие действия:
 
Если младшие четыре бита AL больше 9 или флаг AF = 1, то AL увеличивается на 6, CF устанавливается, если при этом сложении произошел перенос, и AF устанавливается в 1.
 Иначе AF = 0.
  
Если теперь старшие четыре бита AL больше 9 или флаг CF = 1, то AL увеличивается на 60h и CF устанавливается в 1.
 Иначе CF = 0.
 
Флаги AF и CF устанавливаются, если в ходе коррекции происходил перенос из первой или второй цифры соответственно, SF, ZF и PF устанавливаются в соответствии с результатом, флаг OF не определен.
 Команда:
 DAS
 
 
 Назначение:
 BCD-коррекция после вычитания
 
Если эта команда выполняется сразу после SUB (SBB или DEC) и в регистре AL находится разность двух упакованных двоично-десятичных чисел, то в результате в AL записывается упакованное двоично-десятичное число, которое должно было быть результатом вычитания. Например, если AL содержит число 20h, последовательность команд
     dec      al
     das
 
 приведет к тому, что в AL окажется 19h (а не 1Fh, как было бы после DEC).
 
 DAS выполняет следующие действия:
 
Если младшие четыре бита AL больше 9 или флаг AF = 1, то AL уменьшается на 6, CF устанавливается, если при этом вычитании произошел заем, и AF устанавливается в 1.
 Иначе AF = 0.
  
Если теперь старшие четыре бита AL больше 9 или флаг CF = 1, то AL уменьшается на 60h и CF устанавливается в 1.
 Иначе CF = 0.
  
Известный пример необычного использования этой команды — самый компактный вариант преобразования шестнадцатеричной цифры в ASCII-код соответствующего символа (более длинный и очевидный вариант этого преобразования рассматривался в описании команды XLAT):
 
     cmp      al,10
     sbb      al,96h
     das
 
После SBB числа 0 – 9 превращаются в 96h – 9Fh, а числа 0Ah – 0Fh — в 0А1h – 0A6h. Затем DAS вычитает 66h из первой группы чисел, переводя их в 30h – 39h, и 60h из второй группы чисел, переводя их в 41h – 46h.

Флаги AF и CF устанавливаются, если в ходе коррекции происходил заем из первой или второй цифры соответственно, SF, ZF и PF устанавливаются в соответствии с результатом, флаг OF не определен.

 Команда:
 AAA
 
 
 Назначение:
 ASCII-коррекция после сложения
 
Корректирует сумму двух неупакованных двоично-десятичных чисел в AL. Если коррекция приводит к десятичному переносу, АН увеличивается на 1. Эта команда имеет смысл сразу после команды сложения двух таких чисел. Например, если при сложении 05 и 06 в АХ окажется число 000Bh, то команда ААА скорректирует его в 0101h (неупакованное десятичное 11). Флаги CF и OF устанавливаются в 1, если произошел перенос из AL в АН, иначе они равны нулю. Значения флагов OF, SF, ZF и PF не определены.
 Команда:
 AAS
 
 
 Назначение:
 ASCII-коррекция после вычитания
 
Корректирует разность двух неупакованных двоично-десятичных чисел в AL сразу после команды SUB или SBB. Если коррекция приводит к займу, АН уменьшается на 1. Флаги CF и OF устанавливаются в 1, если произошел заем из AL в АН, и в ноль — в противном случае. Значения флагов OF, SF, ZF и PF не определены.
 Команда:
 AAM
 
 
 Назначение:
 ASCII-коррекция после умножения
 
 
Корректирует результат умножения неупакованных двоично-десятичных чисел, находящийся в АХ после выполнения команды MUL, преобразовывая полученный результат в пару неупакованных двоично-десятичных чисел (в АН и AL). Например:
 
     mov      al,5
     mov      bl,5      ; умножить 5 на 5
     mul      bl        ; результат в АХ - 0019h
     aam                ; теперь АХ содержит 0205h
 
ААМ устанавливает флаги SF, ZF и PF в соответствии с результатом и оставляет OF, AF и CF неопределенными.

Код команды ААМ — D4h 0Ah, где 0Ah — основание системы счисления, по отношению к которой выполняется коррекция. Этот байт можно заменить на любое другое число (кроме нуля), и ААМ преобразует АХ к двум неупакованным цифрам любой системы счисления. Такая обобщенная форма ААМ работает на всех процессорах (начиная с 8086), но появляется в документации Intel только с процессоров Pentium. Фактически действие, которое выполняет ААМ, — целочисленное деление AL на 0Ah (или любое другое число в общем случае), частное помещается в AL, и остаток — в АН, так что эту команду часто используют для быстрого деления в высокооптимизированных алгоритмах.

 Команда:
 AAD
 
 
 Назначение:
 ASCII-коррекция перед делением
 
Выполняет коррекцию неупакованного двоично-десятичного числа, находящегося в регистре АХ, так, чтобы последующее деление привело к корректному десятичному результату. Например, разделим десятичное 25 на 5:
 
     mov      ax,0205h  ; 25 в неупакованном формате
     mov      bl,5
     aad                ; теперь в АХ находится 19h
     div      bl        ; АХ = 0005
 
Флаги SF, ZF и PF устанавливаются в соответствии с результатом, OF, AF и CF не определены.

Так же как и команда ААМ, AAD используется с любой системой счисления: ее код — D5h 0Ah, и второй байт можно заменить на любое другое число. Действие AAD состоит в том, что содержимое регистра АН умножается на второй байт команды (0Ah по умолчанию) и складывается с AL, после чего АН обнуляется, так что AAD можно использовать для быстрого умножения на любое число.

Логические операции

 Команда:
 AND приемник, источник
 
 
 Назначение:
 Логическое И
 
Команда выполняет побитовое «логическое И» над приемником (регистр или переменная) и источником (число, регистр или переменная; источник и приемник не могут быть переменными одновременно) и помещает результат в приемник. Любой бит результата равен 1, только если соответствующие биты обоих операндов были равны 1, и равен 0 в остальных случаях. Наиболее часто AND применяют для выборочного обнуления отдельных бит, например, команда
 
     and      al,00001111b
 
обнулит старшие четыре бита регистра AL, сохранив неизменными четыре младших.

Флаги OF и CF обнуляются, SF, ZF и PF устанавливаются в соответствии с результатом, AF не определен.

 
 Команда:
 OR приемник, источник
 
 
 Назначение:
 Логическое ИЛИ
 
Выполняет побитовое «логическое ИЛИ» над приемником (регистр или переменная) и источником (число, регистр или переменная; источник и приемник не могут быть переменными одновременно) и помещает результат в приемник. Любой бит результата равен 0, только если соответствующие биты обоих операндов были равны 0, и равен 1 в остальных случаях. Команду OR чаще всего используют для выборочной установки отдельных бит, например, команда
 
     or      al,00001111b
 
приведет к тому, что младшие четыре бита регистра AL будут установлены в 1.

При выполнении команды OR флаги OF и CF обнуляются, SF, ZF и PF устанавливаются в соответствии с результатом, AF не определен.

 Команда:
 XOR приемник, источник
 
 
 Назначение:
 Логическое исключающее ИЛИ
 
Выполняет побитовое «логическое исключающее ИЛИ» над приемником (регистр или переменная) и источником (число, регистр или переменная; источник и приемник не могут быть переменными одновременно) и помещает результат в приемник. Любой бит результата равен 1, если соответствующие биты операндов различны, и нулю, если одинаковы. XOR используется для самых разных операций, например:
  
     xor      ах,ах      ; обнуление регистра АХ
 
 
 или
 
  
     xor      ах,bх
     xor      bх,ах
     xor      ах,bх      ; меняет местами содержимое АХ и ВХ
 
 
 Оба этих примера могут выполняться быстрее, 
 чем соответствующие очевидные команды
 
  
     mov      ax,0
 
 
 или
 
  
     xchg     ax,bx
 
  
 
 Команда:
 NOT приемник
 
 
 Назначение:
 Инверсия
 
Каждый бит приемника (регистр или переменная), равный нулю, устанавливается в 1, и каждый бит, равный 1, сбрасывается в 0. Флаги не затрагиваются.
 Команда:
 TEST приемник, источник
 
 
 Назначение:
 Логическое сравнение
 
Вычисляет результат действия побитового «логического И» над приемником (регистр или переменная) и источником (число, регистр или переменная; источник и приемник не могут быть переменными одновременно) и устанавливает флаги SF, ZF и PF в соответствии с полученным результатом, не сохраняя результат (флаги OF и CF обнуляются, значение AF не определено). TEST, так же как и СМР, используется в основном в сочетании с командами условного перехода (Jcc), условной пересылки данных (CMOVcc) и условной установки байт (SETcc).

Сдвиговые операции

 
 Команда:
 SAR приемник, счетчик
 
 
 Назначение:
 Арифметический сдвиг вправо
 
 
 Команда:
 SAL приемник, счетчик
 
 
 Назначение:
 Арифметический сдвиг влево
 
 
 Команда:
 SHR приемник, счетчик
 
 
 Назначение:
 Логический сдвиг вправо
 
 
 Команда:
 SHL приемник, счетчик
 
 
 Назначение:
 Логический сдвиг влево
 
Эти четыре команды выполняют двоичный сдвиг приемника (регистр или переменная) вправо (в сторону старшего бита) или влево (в сторону младшего бита) на значение счетчика (число или регистр CL, из которого учитываются только младшие пять бит, которые могут принимать значения от 0 до 31), Операция сдвига на 1 эквивалентна умножению (сдвиг влево) или делению (сдвиг вправо) на 2. Так, число 0010b (2) после сдвига на 1 влево превращается в 0100b (4). Команды SAL и SHL выполняют одну и ту же операцию (на самом деле это одна и та же команда) — на каждый шаг сдвига старший бит заносится в CF, все биты сдвигаются влево на одну позицию, и младший бит обнуляется. Команда SHR выполняет прямо противоположную операцию: младший бит заносится в CF, все биты сдвигаются на 1 вправо, старший бит обнуляется. Эта команда эквивалентна беззнаковому целочисленному делению на 2. Команда SAR действует по аналогии с SHR, только старший бит не обнуляется, а сохраняет предыдущее значение, так что, например, число 11111100b (-4) перейдет в 11111110b (-2). SAR, таким образом, эквивалентна знаковому делению на 2, но, в отличие от IDIV, округление происходит не в сторону нуля, а в сторону отрицательной бесконечности. Так, если разделить -9 на 4 с помощью IDIV, результат будет -2 (и остаток -1), а если выполнить арифметический сдвиг вправо числа -9 на 2, результат будет -3. Сдвиги больше чем на 1 эквивалентны соответствующим сдвигам на 1, выполненным последовательно. Схема всех сдвиговых операций приведена на рис. 7.

Сдвиги на 1 изменяют значение флага OF: SAL/SHL устанавливают его в 1, если после сдвига старший бит изменился (то есть старшие два бита исходного числа не были одинаковыми), и в 0, если старший бит остался тем же. SAR устанавливает OF в 0, и SHR устанавливает OF в значение старшего бита исходного числа. Для сдвигов на несколько бит значение OF не определено. Флаги SF, ZF, PF устанавливаются всеми сдвигами в соответствии с результатом, значение AF не определено (кроме случая, если счетчик сдвига равен нулю, в котором ничего не происходит и флаги не изменяются).

В процессорах 8086 непосредственно можно было задавать в качестве второго операнда только число 1 и при использовании CL учитывать все биты, а не только младшие 5, но уже начиная с 80186 эти команды приняли свой окончательный вид.

 Команда:
 SHRD приемник, источник, счетчик
 
 
 Назначение:
 Сдвиг повышенной точности вправо
 
 
 Команда:
 SHLD приемник, источник, счетчик
 
 
 Назначение:
 Сдвиг повышенной точности влево
 
 
Приемник (регистр или переменная) сдвигается влево (в случае SHLD) или вправо (в случае SHRD) на число бит, указанное в счетчике (число или регистр CL, откуда используются только младшие 5 бит, которые могут принимать значения от 0 до 31). Старший (для SHLD) или младший (в случае SHRD) бит не обнуляется, а считывается из источника (регистр), значение которого не изменяется. Например, если приемник содержал 00101001b, источник 1010b, счетчик равен 3, SHRD даст в результате 01000101b, a SHLD — 01001101b (см. рис. 8).

Флаг OF устанавливается при сдвигах на 1 бит, если изменился знак приемника, и сбрасывается, если знак не изменился; при сдвигах на несколько бит флаг OF не определен. Во всех случаях SF, ZF и PF устанавливаются в соответствии с результатом и AF не определен, кроме случая со сдвигом на 0 бит, в котором значения флагов не изменяются. Если счетчик больше, чем разрядность приемника, — результат и все флаги не определены.

 Команда:
 ROR приемник, счетчик
 
 
 Назначение:
 Циклический сдвиг вправо
 
 
 Команда:
 ROL приемник, счетчик
 
 
 Назначение:
 Циклический сдвиг влево
 
 
 Команда:
 RCR приемник, счетчик
 
 
 Назначение:
 Циклический сдвиг вправо через флаг переноса
 
 
 Команда:
 RCL приемник, счетчик
 
 
 Назначение:
 Циклический сдвиг влево через флаг переноса
 
Эти команды осуществляют циклический сдвиг приемника (регистр или переменная) на число бит, указанное в счетчике (число или регистр CL, из которого учитываются только младшие пять бит, принимающие значения от 0 до 31). При выполнении циклического сдвига на 1 команды ROR (ROL) сдвигают каждый бит приемника вправо (влево) на одну позицию, за исключением самого младшего (старшего), который записывается в позицию самого старшего (младшего) бита. Команды RCR и RCL выполняют аналогичное действие, но включают флаг CF в цикл, как если бы он был дополнительным битом в приемнике (рис. 9).

Операции над битами и байтами

 Команда:
 BT база, смещение
 
 
 Назначение:
 Проверка бита
 
Команда ВТ считывает во флаг CF значение бита из битовой строки, указанной первым операндом, битовой базой (регистр или переменная), со смещением, указанным во втором операнде, битовом смещении (число или регистр). Если первый операнд — регистр, то битовой базой считается бит 0 в указанном регистре и смещение не может превышать 15 или 31 (в зависимости от размера регистра); если оно превышает эти границы, в качестве смещения будет использован остаток от деления его на 16 или 32 соответственно. Если первый операнд — переменная, то в качестве битовой базы используется бит 0 указанного байта в памяти, а смещение может принимать значения от 0 до 31, если оно указано непосредственно (старшие биты процессором игнорируются), и от -231 до 231–1, если оно указано в регистре.

Несмотря на то что эта команда считывает единственный бит из памяти, процессор считывает целое двойное слово по адресу База+(4*(Смещение/32)) или слово по адресу База+(2*(Смещение/16)), в зависимости от разрядности адреса, так что не следует пользоваться ВТ вблизи от не доступных для чтения областей памяти.

После выполнения команды ВТ флаг CF равен значению считанного бита, флаги OF, SF, ZF, AF и PF не определены.

 Команда:
 BTS база, смещение
 
 
 Назначение:
 Проверка и установка бита
 
 
 Команда:
 BTR база, смещение
 
 
 Назначение:
 Проверка и сброс бита
 
 
 Команда:
 BTC база, смещение
 
 
 Назначение:
 Проверка и инверсия бита
 
Эти три команды соответственно устанавливают в 1 (BTS), сбрасывают в 0 (ВТR) и инвертируют (ВТС) значение бита, который находится в битовой строке с началом, указанным в базе (регистр или переменная), и смещением, указанным во втором операнде (число от 0 до 31 или регистр). Если битовая база — регистр, то смещение не может превышать 15 или 31 в зависимости от разрядности этого регистра. Если битовая база — переменная в памяти, то смещение может принимать значения от -231 до 231–1 (если оно указано в регистре).

После выполнения команд BTS, BTR и ВТС флаг CF равен значению считанного бита до его изменения в результате действия команды, флаги OF, SF, ZF, AF и PF не определены.

 Команда:
 BSF приемник, источник
 
 
 Назначение:
 Прямой поиск бита
 
 
 Команда:
 BSR база, смещение
 
 
 Назначение:
 Обратный поиск бита
 
BSF сканирует источник (регистр или переменная), начиная с самого младшего бита, и записывает в приемник (регистр) номер первого встретившегося бита, равного 1. Команда BSR сканирует источник, начиная с самого старшего бита, и возвращает номер первого встретившегося ненулевого бита, считая от нуля, то есть, если источник равен 0100 0000 0000 0010b, то BSF возвратит 1 a BSR — 14.

Если весь источник равен нулю, значение приемника не определено и флаг ZF устанавливается в 1, иначе ZF всегда сбрасывается. Флаги CF, OF, SF, AF и PF не определены.

 Команда:
 SETcc приемник
 
 
 Назначение:
 Установка байта по условию
 
Это набор команд, которые устанавливают приемник (восьмибитный регистр или переменная размером в один байт) в 1 или 0, если удовлетворяется или не удовлетворяется определенное условие. Условием в каждом случае реально является состояние тех или иных флагов, но, если команда из набора SETcc используется сразу после СМР, условия приобретают формулировки, соответствующие отношениям между операндами СМР (см. табл. 6). Скажем, если операнды СМР были неравны, то команда SETNE, выполненная сразу после этого СМР, установит значение своего операнда в 1.

Команды передачи управления

 Команда:
 JMP операнд
 
 
 Назначение:
 Безусловный переход
 
JMP передает управление в другую точку программы, не сохраняя какой-либо информации для возврата. Операндом может быть непосредственный адрес для перехода (в программах используют имя метки, установленной перед командой, на которую выполняется переход), а также регистр или переменная, содержащая адрес.

В зависимости от типа перехода различают:

переход типа short (короткий переход) — если адрес перехода находится в пределах от -127 до +128 байт от команды JMP;

переход типа near (ближний переход) — если адрес перехода находится в том же сегменте памяти, что и команда JMP;

переход типа far (дальний переход) — если адрес перехода находится в другом сегменте. Дальний переход может выполняться и в тот же самый сегмент, если в сегментной части операнда указано число, совпадающее с текущим значением CS;

переход с переключением задачи — передача управления другой задаче в многозадачной среде. Этот вариант будет рассмотрен в главе, посвященной защищенному режиму.

При выполнении переходов типа short и near команда JMP фактически изменяет значение регистра EIP (или IP), изменяя тем самым смещение следующей исполняемой команды относительно начала сегмента кода. Если операнд — регистр или переменная в памяти, то его значение просто копируется в EIP, как если бы это была команда MOV. Если операнд для JMP — непосредственно указанное число, то его значение суммируется с содержимым EIP, приводя к относительному переходу. В ассемблерных программах в качестве операнда обычно указывают имена меток, но на уровне исполнимого кода ассемблер вычисляет и записывает именно относительные смещения.

Выполняя дальний переход в реальном режиме, виртуальном режиме и в защищенном режиме (при переходе в сегмент с теми же привилегиями), команда JMP просто загружает новое значение в EIP и новый селектор сегмента кода в CS, используя старшие 16 бит операнда как новое значение для CS и младшие 16 или 32 — как значение IP или EIP.

 
 Команда:
 Jcc метка
 
 
 Назначение:
 Условный переход
 
Это набор команд, каждая из которых выполняет переход (типа short или near), если удовлетворяется соответствующее условие. Условием в каждом случае реально является состояние тех или иных флагов, но, если команда из набора Jcc используется сразу после СМР, условия приобретают формулировки, соответствующие отношениям между операндами СМР (см. табл. 7). Например, если операнды СМР были равны, то команда JE, выполненная сразу после этого СМР, осуществит переход. Операнд для всех команд из набора Jcc — 8-битное или 32-битное смешение относительно текущей команды.

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

     cmp      ах,0
     jne      local_1
     jmp      far_label  ; переход, если АХ = 0
 lосаl_1:
 
  
 
 Команда:
 JCXZ метка
 
 
 Назначение:
 Переход, если СХ = 0
 
 Команда:
 JECXZ метка
 
 
 Назначение:
 Переход, если EСХ = 0
 
 
Выполняет ближний переход на указанную метку, если регистр CX или ECX (для JCXZ и JECXZ соответственно) равен нулю. Так же как и команды из серии Jcc, JCXZ и JECXZ не могут выполнять дальних переходов. Проверка равенства СХ нулю, например, может потребоваться в начале цикла, организованного командой LOOPNE, — если в него войти с СХ = 0, то он будет выполнен 65 535 раз.
 Команда:
 LOOP метка
 
 
 Назначение:
 Цикл
 
 
Уменьшает регистр ЕСХ на 1 и выполняет переход типа short на метку (которая не может быть дальше, чем на расстоянии от -128 до +127 байт от команды LOOP), если ЕСХ не равен нулю. Эта команда используется для организации циклов, в которых регистр ЕСХ (или СХ при 16-битной адресации) играет роль счетчика. Так, в следующем фрагменте команда ADD выполнится 10 раз:
 
             mov   cx,0Ah
 loop_start: add   ax,cx
             loop  loop_start
 
 
 Команда LOOP полностью эквивалентна паре команд
 
  
             dec   ecx
             jz    метка
 
 
 Но LOOP короче этих двух команд на один байт и не изменяет значения флагов.
 
  
 
 Команда:
 LOOPE метка
 
 
 Назначение:
 Цикл, пока равно
 
 
 Команда:
 LOOPZ метка
 
 
 Назначение:
 Цикл, пока ноль
 
 
 Команда:
 LOOPNE метка
 
 
 Назначение:
 Цикл, пока не равно
 
 
 Команда:
 LOOPNZ метка
 
 
 Назначение:
 Цикл, пока не ноль
 
 
Все эти команды уменьшают регистр ЕСХ на один, после чего выполняют переход типа short, если ЕСХ не равен нулю и если выполняется условие. Для команд LOOPE и LOOPZ условием является равенство единице флага ZF, для команд LOOPNE и LOOPNZ — равенство флага ZF нулю. Сами команды LOOPcc не изменяют значений флагов, так что ZF должен быть установлен (или сброшен) предшествующей командой. Например, следующий фрагмент копирует строку из DS:SI в строку в ES:DI (см. описание команд работы со строками), пока не кончится строка (СХ = 0) или пока не встретится символ с ASCII-кодом 13 (конец строки):
 
            mov     cx,str_length
 move_loop:
            stosb
            lodsb
            cmp     al,13
            loopnz  move_loop
 
  
 
 Команда:
 CALL операнд
 
 
 Назначение:
 Вызов процедуры
 
Сохраняет текущий адрес в стеке и передает управление по адресу, указанному в операнде. Операндом может быть непосредственное значение адреса (метка в ассемблерных программах), регистр или переменная, содержащие адрес перехода. Если в качестве адреса перехода указано только смещение, считается, что адрес расположен в том же сегменте, что и команда CALL. При этом, так же как и в случае с JMP, выполняется ближний вызов процедуры. Процессор помещает значение регистра EIP (IP при 16-битной адресации), соответствующее следующей за CALL команде, в стек и загружает в EIP новое значение, осуществляя тем самым передачу управления. Если операнд CALL — регистр или переменная, то его значение рассматривается как абсолютное смещение, если операнд — метка в программе, то ассемблер указывает ее относительное смещение. Чтобы осуществить дальний CALL в реальном режиме, режиме V86 или в защищенном режиме при переходе в сегмент с теми же привилегиями, процессор помещает в стек значения регистров CS и EIP (IP при 16-битной адресации) и выполняет дальний переход аналогично команде JMP.
 Команда:
 RET число
 RETN число
 RETF число
 
 
 Назначение:
 Возврат из процедуры
 
 
RETN считывает из стека слово (или двойное слово, в зависимости от режима адресации) и загружает его в IP (или EIP), выполняя тем самым действия, обратные ближнему вызову процедуры командой, CALL. RETF соответственно загружает из стека IP (EIP) и CS, возвращаясь из дальней процедуры. Если в ассемблерной программе указана команда RET, ассемблер заменит ее на RETN или RETF в зависимости от того, как была описана процедура, которую эта команда завершает. Операнд для RET необязателен, но, если он присутствует, после считывания адреса возврата из стека будет удалено указанное количество байт — это бывает нужно, если при вызове процедуры ей передавались параметры через стек.
 Команда:
 INT число
 
 
 Назначение:
 Вызов прерывания
 
INT помещает в стек содержимое регистров EFLAGS, CS и EIP, после чего передает управление программе, называемой «обработчик прерывания» с указанным в качестве операнда номером (число от 0 до 0FFh), аналогично команде CALL. В реальном режиме адреса обработчиков прерываний считываются из таблицы, начинающейся в памяти по адресу 0000h:0000h. Адрес каждого обработчика занимает 4 байта, так что, например, адрес обработчика прерывания 10h находится в памяти по адресу 0000h:0040h. В защищенном режиме адреса обработчиков прерываний находятся в таблице IDT и обычно недоступны для прямого чтения или записи, так что для установки собственного обработчика программа должна обращаться к операционной системе. В DOS вызовы прерываний используются для выполнения большинства системных функций — работы с файлами, вводом/выводом и т.д. Например, следующий фрагмент кода завершает выполнение программы и возвращает управление DOS:
 
     mov      ax,4C01h
     int      21h
 
  
 
 Команда:
 IRET
 IRETD
 
 
 Назначение:
 Возврат из обработчика прерывания
 
Возврат управления из обработчика прерывания или исключения. IRЕТ загружает из стека значения IP, CS и FLAGS, a IRETD — EIP, CS и EFLAGS соответственно. Единственное отличие IRET от RETF состоит в том, что восстанавливается значение регистра флагов, из-за чего многим обработчикам прерываний приходится изменять значение EFLAGS, находящегося в стеке, чтобы, например, вернуть флаг CF установленным в случае ошибки.
 Команда:
 INT3
 
 
 Назначение:
 Вызов прерывания 3
 
Размер этой команды — один байт (код 0CCh), что делает ее удобной для отладки программ отладчиками, работающими в реальном режиме. Такие отладчики записывают этот байт вместо первого байта команды, перед которой требуется точка останова, и переопределяют адрес обработчика прерывания 3 на соответствующую процедуру внутри отладчика.
 Команда:
 INTO
 
 
 Назначение:
 Вызов прерывания 4 при переполнении
 
INTO — еще одна специальная форма команды INT. Эта команда вызывает обработчик прерывания 4, если флаг OF установлен в 1.
 Команда:
 BOUND индекс, границы
 
 
 Назначение:
 Проверка выхода за границы массива
 
BOUND проверяет, не выходит ли значение первого операнда (регистр), взятое как число со знаком, за границы, указанные во втором операнде (переменная). Границы — два слова или двойных слова (в зависимости от разрядности операндов), рассматриваемые как целые со знаком, расположенные в памяти подряд. Первая граница считается нижней, вторая — верхней. Если индекс меньше нижней границы или больше верхней, вызывается прерывание 5 (или исключение #BR), причем адрес возврата указывает не на следующую команду, а на BOUND, так что обработчик должен исправить значение индекса или границ, прежде чем выполнять команду IRET.
 Команда:
 ENTER размер, уровень
 
 
 Назначение:
 Вход в процедуру
 
Команда ENTER создает стековый кадр заданного размера и уровня вложенности (оба операнда — числа; уровень вложенности может принимать значения только от 0 до 31) для вызова процедуры, использующей динамическое распределение памяти в стеке для своих локальных переменных. Так, команда
     enter    2048,3
 
помещает в стек указатели на стековый кадр текущей процедуры и той, из которой вызывалась текущая, создает стековый кадр размером 2 килобайта для вызываемой процедуры и помещает в ЕВР адрес начала кадра. Пусть процедура MAIN имеет уровень вложенности 0, процедура PROCA запускается из MAIN и имеет уровень вложенности 1, и PROCB запускается из PROCA с уровнем вложенности 2.

Строковые операции

Все команды для работы со строками считают, что строка-источник находится по адресу DS:SI (или DS:ESI), то есть в сегменте памяти, указанном в DS со смещением в SI, а строка-приемник — соответственно в ES:DI (или ES:EDI). Кроме того, все строковые команды работают только с одним элементом строки (байтом, словом или двойным словом) за один раз. Для того чтобы команда выполнялась над всей строкой, необходим один из префиксов повторения операций.
 Префикс:
 REP
 
 
 Назначение:
 Повторять
 
 
 Префикс:
 REPE
 
 
 Назначение:
 Повторять, пока равно
 
 
 Префикс:
 REPNE
 
 
 Назначение:
 Повторять, пока не равно
 
 
 Префикс:
 REPZ
 
 
 Назначение:
 Повторять, пока ноль
 
 
 Префикс:
 REPNZ
 
 
 Назначение:
 Повторять, пока не ноль
 
 
Все эти команды — префиксы для операций над строками. Любой из префиксов выполняет следующую за ним команду строковой обработки столько раз, сколько указано в регистре ЕСХ (или СХ, в зависимости от разрядности адреса), уменьшая его при каждом выполнении команды на 1. Кроме того, префиксы REPZ и REPE прекращают повторения команды, если флаг ZF сброшен в 0, и префиксы REPNZ и REPNE прекращают повторения, если флаг ZF установлен в 1. Префикс REP обычно используется с командами INS, OUTS, MOVS, LODS, STOS, а префиксы REPE, REPNE, REPZ и REPNZ — с командами CMPS и SCAS. Поведение префиксов не с командами строковой обработки не определено.
 Команда:
 MOVS приемник, источник
 
 
 Назначение:
 Копирование строки
 
 
 Процессор:
 8086
 
 
 Команда:
 MOVSB
 
 
 Назначение:
 Копирование строки байт
 
 
 Процессор:
 8086
 
 
 Команда:
 MOVSW
 
 
 Назначение:
 Копирование строки слов
 
 
 Процессор:
 8086
 
 
 Команда:
 MOVSD
 
 
 Назначение:
 Копирование строки двойных слов
 
 
Копирует один байт (MOVSB), слово (MOVSW) или двойное слово (MOVSD) из памяти по адресу DS:ESI (или DS:SI, в зависимости от разрядности адреса) в память по адресу ES:EDI (или ES:DI). При использовании формы записи MOVS ассемблер сам определяет из типа указанных операндов (принято указывать имена копируемых строк, но можно использовать любые два операнда подходящего типа), какую из трех форм этой команды (MOVSB, MOVSW или MOVSD) выбрать. Используя MOVS с операндами, можно заменить регистр DS на другой с помощью префикса замены сегмента (ES:, GS:, FS:, CS:, SS:), регистр ES заменить нельзя. После выполнения команды регистры ESI (SI) и EDI (DI) увеличиваются на 1, 2 или 4 (если копируются байты, слова или двойные слова), если флаг DF = 0, и уменьшаются, если DF = 1. При использовании с префиксом REP команда MOVS выполняет копирование строки длиной в ЕСХ (или СХ) байт, слов или двойных слов.
 Команда:
 CMPS приемник, источник
 
 
 Назначение:
 Сравнение строк
 
 
 Процессор:
 8086
 
 
 Команда:
 CMPSB
 
 
 Назначение:
 Сравнение строк байт
 
 
 Процессор:
 8086
 
 
 Команда:
 CMPSW
 
 
 Назначение:
 Сравнение строк слов
 
 
 Процессор:
 8086
 
 
 Команда:
 CMPSD
 
 
 Назначение:
 Сравнение строк двойных слов
 
Сравнивает один байт (CMPSB), слово (CMPSW) или двойное слово (CMPSD) из памяти по адресу DS:ESI (или DS:SI, в зависимости от разрядности адреса) с байтом, словом или двойным словом по адресу ES:EDI (или ES:DI) и устанавливает флаги аналогично команде СМР. При использовании формы записи CMPS ассемблер сам определяет из типа указанных операндов (принято указывать имена сравниваемых строк, но можно использовать любые два операнда подходящего типа), какую из трех форм этой команды (CMPSB, CMPSW или CMPSD) выбрать. Используя CMPS с операндами, можно заменить регистр DS на другой, применяя префикс замены сегмента (ES:, GS:, FS:, CS:, SS:), регистр ES заменить нельзя. После выполнения команды регистры ESI (SI) и EDI (DI) увеличиваются на 1, 2 или 4 (если сравниваются байты, слова или двойные слова), если флаг DF = 0, и уменьшаются, если DF = 1. При использовании с префиксом REP команда CMPS выполняет сравнение строки длиной в ЕСХ (или СХ) байт, слов или двойных слов, но чаще ее используют с префиксами REPNE/REPNZ или REPE/REPZ. В первом случае сравнение продолжается до первого несовпадения в сравниваемых строках, а во втором — до первого совпадения.
 Команда:
 SCAS приемник
 
 
 Назначение:
 Сканирование строки
 
 
 Процессор:
 8086
 
 
 Команда:
 SCASB
 
 
 Назначение:
 Сканирование строки байт
 
 
 Процессор:
 8086
 
 
 Команда:
 SCASW
 
 
 Назначение:
 Сканирование строки слов
 
 
 Процессор:
 8086
 
 
 Команда:
 SCASD
 
 
 Назначение:
 Сканирование строки двойных слов
 
Сравнивает содержимое регистра AL (SCASB), AX (SCASW) или ЕАХ (SCASD) с байтом, словом или двойным словом из памяти по адресу ES:EDI (или ES:DI, в зависимости от разрядности адреса) и устанавливает флаги аналогично команде СМР. При использовании формы записи SCAS ассемблер сам определяет из типа указанного операнда (принято указывать имя сканируемой строки, но можно использовать любой операнд подходящего типа), какую из трех форм этой команды (SCASB, SCASW или SCASD) выбрать. После выполнения команды регистр EDI (DI) увеличивается на 1, 2 или 4 (если сканируются байты, слова или двойные слова), если флаг DF = 0, и уменьшается, если DF = 1. При использовании с префиксом REP команда SCAS выполняет сканирование строки длиной в ЕСХ (или СХ) байт, слов или двойных слов, но чаще ее используют с префиксами REPNE/REPNZ или REPE/REPZ. В первом случае сканирование продолжается до первого элемента строки, отличного от содержимого аккумулятора, а во втором — до первого совпадающего.
 Команда:
 LODS источник
 
 
 Назначение:
 Чтение из строки
 
 
 Процессор:
 8086
 
 
 Команда:
 LODSB
 
 
 Назначение:
 Чтение байта из строки
 
 
 Процессор:
 8086
 
 
 Команда:
 LODSW
 
 
 Назначение:
 Чтение слова из строки
 
 
 Процессор:
 8086
 
 
 Команда:
 LODSD
 
 
 Назначение:
 Чтение двойного слова из строки
 
Копирует один байт (LODSB), слово (LODSW) или двойное слово (LODSD) из памяти по адресу DS:ESI (или DS:SI, в зависимости от разрядности адреса) в регистр AL, АХ или ЕАХ соответственно. При использовании формы записи LODS ассемблер сам определяет из типа указанного операнда (принято указывать имя строки, но можно использовать любой операнд подходящего типа), какую из трех форм этой команды (LODSB, LODSW или LODSD) выбрать. Используя LODS с операндом, можно заменить регистр DS на другой с помощью префикса замены сегмента (ES:, GS:, FS:, CS:, SS:). После выполнения команды регистр ESI (SI) увеличивается на 1, 2 или 4 (если считывается байт, слово или двойное слово), если флаг DF = 0, и уменьшается, если DF = 1. При использовании с префиксом REP команда LODS выполнит копирование строки длиной в ЕСХ (или СХ), что приведет к тому, что в аккумуляторе окажется последний элемент строки. На самом деле эту команду используют без префиксов, часто внутри цикла в паре с командой STOS, так что LODS считывает число, другие команды выполняют над ним какие-нибудь действия, а затем STOS записывает измененное число в то же место в памяти.
 Команда:
 STOS приемник
 
 
 Назначение:
 Запись в строку
 
 
 Процессор:
 8086
 
 
 Команда:
 STOSB
 
 
 Назначение:
 Запись байта в строку
 
 
 Процессор:
 8086
 
 
 Команда:
 STOSW
 
 
 Назначение:
 Запись слова в строку
 
 
 Процессор:
 8086
 
 
 Команда:
 STOSD
 
 
 Назначение:
 Запись двойного слова в строку
 
Копирует регистр AL (STOSB), AX (STOSW) или ЕАХ (STOSD) в память по адресу ES:EDI (или ES:DI, в зависимости от разрядности адреса). При использовании формы записи STOS ассемблер сам определяет из типа указанного операнда (принято указывать имя строки, но можно использовать любой операнд подходящего типа), какую из трех форм этой команды (STOSB, STOSW или STOSD) выбрать. После выполнения команды регистр EDI (DI) увеличивается на 1, 2 или 4 (если копируется байт, слово или двойное слово), если флаг DF = 0, и уменьшается, если DF = 1. При использовании с префиксом REP команда STOS заполнит строку длиной в ЕСХ (или СХ) числом, находящимся в аккумуляторе.
 Команда:
 INS источник, DX
 
 
 Назначение:
 Чтение строки из порта
 
 
 Процессор:
 80186
 
 
 Команда:
 INSB
 
 
 Назначение:
 Чтение строки байт из порта
 
 
 Процессор:
 80186
 
 
 Команда:
 INSW
 
 
 Назначение:
 Чтение строки слов из порта
 
 
 Процессор:
 80186
 
 
 Команда:
 INSD
 
 
 Назначение:
 Чтение строки двойных слов из порта
 
Считывает из порта ввода-вывода, номер которого указан в регистре DX, байт (INSB), слово (INSW) или двойное слово (INSD) в память по адресу ES:EDI (или ES:DI, в зависимости от разрядности адреса). При использовании формы записи INS ассемблер определяет из типа указанного операнда, какую из трех форм этой команды (INSB, INSW или INSD) употребить. После выполнения команды регистр EDI (DI) увеличивается на 1, 2 или 4 (если считывается байт, слово или двойное слово), если флаг DF = 0, и уменьшается, если DF = 1. При использовании с префиксом REP команда INS считывает блок данных из порта длиной в ЕСХ (или СХ) байт, слов или двойных слов.
 Команда:
 OUTS DX, приемник
 
 
 Назначение:
 Запись строки в порт
 
 
 Процессор:
 80186
 
 
 Команда:
 OUTSB
 
 
 Назначение:
 Запись строки байт в порт
 
 
 Процессор:
 80186
 
 
 Команда:
 OUTSW
 
 
 Назначение:
 Запись строки слов в порт
 
 
 Процессор:
 80186
 
 
 Команда:
 OUTSD
 
 
 Назначение:
 Запись строки двойных слов в порт
 
Записывает в порт ввода-вывода, номер которого указан в регистре DX, байт (OUTSB), слово (OUTSW) или двойное слово (OUTSD) из памяти по адресу DS:ESI (или DS:SI, в зависимости от разрядности адреса). При использовании формы записи OUTS ассемблер определяет из типа указанного операнда, какую из трех форм этой команды (OUTSB, OUTSW или OUTSD) употребить. Используя OUTS с операндами, также можно заменить регистр DS на другой с помощью префикса замены сегмента (ES:, GS:, FS:, CS:, SS:). После выполнения команды регистр ESI (SI) увеличивается на 1, 2 или 4 (если считывается байт, слово или двойное слово), если флаг DF = 0, и уменьшается, если DF = 1. При использовании с префиксом REP команда OUTS записывает блок данных размером в ЕСХ (или СХ) байт, слов или двойных слов в указанный порт. Все процессоры вплоть до Pentium не проверяли готовность порта принять новые данные в ходе выполнения команды REP OUTS, так что, если порт не успевал обрабатывать информацию с той скоростью, с которой ее поставляла эта команда, часть данных терялась.

Управление флагами

 Команда:
 STC
 
 
 Назначение:
 Установить флаг переноса
 
 Устанавливает флаг CF в 1.
 
  
 
 Команда:
 CLC
 
 
 Назначение:
 Сбросить флаг переноса
 
 
 Процессор:
 8086
 
 
 Сбрасывает флаг CF в 0.
 
  
 
 Команда:
 CMC
 
 
 Назначение:
 Инвертировать флаг переноса
 
 
 Процессор:
 8086
 
 
 Инвертирует флаг СF.
 
  
 
 Команда:
 STD
 
 
 Назначение:
 Установить флаг направления
 
 
Устанавливает флаг DF в 1, так что при последующих строковых операциях регистры DI и SI будут уменьшаться.
  
 
 Команда:
 CLD
 
 
 Назначение:
 Сбросить флаг направления
 
Сбрасывает флаг DF в 0, так что при последующих строковых операциях регистры DI и SI будут увеличиваться.
 Команда:
 LAHF
 
 
 Назначение:
 Загрузить флаги состояния в АН
 
 
Копирует младший байт регистра FLAGS в АН, включая флаги SF (бит 7), ZF (бит 6), AF (бит 4), PF (бит 2) и CF (бит 0). Бит 1 устанавливается в 1, биты 3 и 5 — в 0.
 Команда:
 SAHF
 
 
 Назначение:
 Загрузить флаги состояния из АН
 
Загружает флаги SF, ZF, AF, PF и CF из регистра АН значениями бит 7, 6, 4, 2 и 0 соответственно. Зарезервированные биты 1, 3 и 5 регистра флагов не изменяются.
 Команда:
 PUSHF
 
 
 Назначение:
 Поместить FLAGS в стек
 
 Команда:
 PUSHFD
 
 
 Назначение:
 Поместить ЕFLAGS в стек
 
Эти команды копируют содержание регистра FLAGS или EFLAGS в стек (уменьшая SP или ESP на 2 или 4 соответственно). При копировании регистра EFLAGS флаги VM и RF (биты 16 и 17) не копируются, соответствующие биты в двойном слове, помещенном в стек, обнуляются.
 Команда:
 POPF
 
 
 Назначение:
 Загрузить FLAGS из стека
 
 
 Процессор:
 8086
 
 
 Команда:
 POPFD
 
 
 Назначение:
 Загрузить EFLAGS из стека
 
Считывает из вершины стека слово (POPF) или двойное слово (POPFD) и помещает в регистр FLAGS или EFLAGS. Эффект этих команд зависит от режима, в котором выполняется программа: в реальном режиме и в защищенном режиме с уровнем привилегий 0 модифицируются все незарезервированные флаги в EFLAGS, кроме VIP, VIF и VM. VIP и VIF обнуляются, и VM не изменяется. В защищенном режиме c уровнем привилегий, большим нуля, но меньшим или равным IOPL, модифицируются все флаги, кроме VIP, VIF, VM и IOPL. В режиме V86 не модифицируются флаги VIF, VIP, VM, IOPL и RF.
 Команда:
 CLI
 
 Назначение:
 Запретить прерывания
 
Сбрасывает флаг IF в 0. После выполнения этой команды процессор игнорирует все прерывания от внешних устройств (кроме NMI). В защищенном режиме эта команда, так же как и все другие команды, модифицирующие флаг IF (POPF или IRET), выполняется, только если программе даны соответствующие привилегии (CPL < IOPL).
 Команда:
 STI
 
 Назначение:
 Разрешить прерывания
 
 Устанавливает флаг IF в 1, отменяя тем самым действие команды CLI.
 
  
 
 Команда:
 SALC
 
 
 Назначение:
 Установить AL в соответствии с CF
 
Устанавливает AL в 0FFh, если флаг CF = 1, и сбрасывает в 00h, если CF = 0. Это недокументированная команда с кодом 0D6h, присутствующая во всех процессорах Intel и совместимых с ними (начиная с 8086). В документации на Pentium Pro эта команда упоминается в общем списке команд, но ее действие не описывается. Действие SALC аналогично SBB AL,AL, но SALC не изменяет значений флагов.

Загрузка сегментных регистров

 Команда:
 LDS приемник, источник
 
 
 Назначение:
 Загрузить адрес, используя DS
 
 Команда:
 LES приемник, источник
 
 
 Назначение:
 Загрузить адрес, используя ES
 
 Команда:
 LFS приемник, источник
 
 
 Назначение:
 Загрузить адрес, используя FS
 
 Команда:
 LGS приемник, источник
 
 
 Назначение:
 Загрузить адрес, используя GS
 
 Команда:
 LSS приемник, источник
 
 
 Назначение:
 Загрузить адрес, используя SS
 
 
Второй операнд (источник) для всех этих команд — переменная в памяти размером в 32 или 48 бит (в зависимости от разрядности операндов). Первые 16 бит из этой переменной загружаются в соответствующий сегментный регистр (DS для LDS, ES для LES и т.д.), а следующие 16 или 32 — в регистр общего назначения, указанный в качестве первого операнда. В защищенном режиме значение, загружаемое в сегментный регистр, всегда должно быть правильным селектором сегмента (в реальном режиме любое число может использоваться как селектор).

Другие команды

 Команда:
 NOP
 
 
 Назначение:
 Отсутствие операции
 
 
NOP — однобайтная команда (код 90h), которая не выполняет ничего, только занимает место и время. Код этой команды фактически соответствует команде XCHG AL,AL. Можно многие команды записать так, что они не будут приводить ни к каким действиям, например:
  
     mov      ax,ax         ; 2 байта
     xchg     ax,ax         ; 2 байта
     lea      bx,[bx+0]     ; 3 байта (8Dh, 5Fh, 00h, но многие
                            ; ассемблеры, встретив такую команду,
                            ; реально используют более короткую команду
                            ; lea bx,[bx] с кодом 8Dh 1Fh)
     shl      eax,0         ; 4 байта
     shrd     еах,еах,0     ; 5 байт
 
 
 Префикс:
 LOCK
 
 
 Назначение:
 Префикс блокировки шины данных
 
 
На все время выполнения команды, снабженной таким префиксом, будет заблокирована шина данных, и если в системе присутствует другой процессор, он не сможет обращаться к памяти, пока не закончится выполнение команды с префиксом LOCK. Команда XCHG автоматически всегда выполняется с блокировкой доступа к памяти, даже если префикс LOCK не указан. Этот префикс можно использовать только с командами ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG, DEC, INC, NEG, NOT, OR, SBB, SUB, XOR, XADD и XCHG.
 Команда:
 UD2
 
 
 Назначение:
 Неопределенная операция
 
 
Эта команда всегда вызывает ошибку «неопределенная операция» (исключение #UD). Впервые она описана как таковая для Pentium Pro, но во всех предыдущих процессорах эта команда (код 0Fh 0Bh) не была определена и, естественно, приводила к такой же ошибке. UD2 предназначена для тестирования программного обеспечения, в частности операционных систем, которые должны уметь корректно обрабатывать такую ошибку. Название команды происходит от команды UD (код 0Fh 0FFh), которая была определена AMD для процессоров AMD K5.
 Команда:
 CPUID
 
 
 Назначение:
 Идентификация процессора
 
CPUID сообщает информацию о производителе, типе и модификации процессора, о наличии и поддержке различных расширений. Команда CPUID поддерживается Intel, начиная с процессоров Intel 80486DX/SX/DX2 SL, UMC U5S, Cyrix M1, AMD 80486DX4. Чтобы проверить, поддерживает ли процессор эту команду, попробуйте установить флаг ID в 1 (бит 21 в регистре EFLAGS) — если это получается, значит, команда CPUID поддерживается.

Результат работы CPUID зависит от значения регистра ЕАХ. Если ЕАХ = 0, CPUID возвращает в ЕАХ максимальное значение, с которым ее можно вызывать (2 для Р6, 1 для Р5), а регистры EBX:ECX:EDX содержат 12-байтную строку — идентификатор производителя

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

Псевдокоманда — это директива ассемблера, которая приводит к включению данных или кода в программу, хотя сама она никакой команде процессора не соответствует. Псевдокоманды определения переменных указывают ассемблеру, что в соответствующем месте программы располагается переменная, определяют тип переменной (байт, слово, вещественное число и т.д.), задают ее начальное значение и ставят в соответствие переменной метку, которая будет использоваться для обращения к этим данным. Псевдокоманды определения данных записываются в общем виде следующим образом:
  
 имя_переменной   d*      значение
 
 
 где D* — одна из нижеприведенных псевдокоманд:
 
  
 
 DB — определить байт;
 
  
 
 DW — определить слово (2 байта);
 
  
 
 DD — определить двойное слово (4 байта);
 
  
 
 DF — определить 6 байт (адрес в формате 16-битный селектор: 
                                 32-битное смещение);
 
  
 
 DQ — определить учетверенное слово (8 байт);
 
  
 
 DT — определить 10 байт (80-битные типы данных, используемые FPU).
 
Поле значения может содержать одно или несколько чисел, строк символов (взятых в одиночные или двойные кавычки), операторов ? и DUP, разделенных запятыми. Все установленные таким образом данные окажутся в выходном файле, а имя переменной будет соответствовать адресу первого из указанных значений. Например, набор директив
 
 text_string    db   'Hello world!'
 number         dw   7
 table          db   1,2,3,4,5,6,7,8,9,0Ah,0Bh,0Ch,0Dh,0Eh,0Fh
 float_number   dd   3.5e7
 
заполняет данными 33 байта. Первые 12 байт содержат ASCII-коды символов строки «Hello world!», и переменная text_string указывает на первую букву в этой строке, так что команда
         mov      al,text_string
 
считает в регистр AL число 48h (код латинской буквы H). Если вместо точного значения указан знак ?, переменная считается неинициализированной и ее значение на момент запуска программы может оказаться любым. Если нужно заполнить участок памяти повторяющимися данными, используется специальный оператор DUP, имеющий формат счетчик DUP (значение). Например, вот такое определение:
 table_512w     dw   512 dup(?)
 
создает массив из 512 неинициализированных слов, на первое из которых указывает переменная table_512w. В качестве аргумента в операторе DUP могут выступать несколько значений, разделенных запятыми, и даже дополнительные вложенные операторы DUP.

Структуры

Директива STRUC позволяет определить структуру данных аналогично структурам в языках высокого уровня. Последовательность директив
 
 имя           struc
               поля
 имя           ends
 
где поля — любой набор псевдокоманд определения переменных или структур, устанавливает, но не инициализирует структуру данных. В дальнейшем для ее создания в памяти используют имя структуры как псевдокоманду:
 
 метка         имя   <значения>
 
И наконец, для чтения или записи в элемент структуры используется оператор «.» (точка). Например:
  
 point      struc                        ; Определение структуры
 x          dw       0                   ; Три слова со значениями
 y          dw       0                   ; по умолчанию 0,0,0
 z          dw       0
 color      db       3 dup(?)            ; и три байта
 point      ends
 
 cur_point  point    <1,1,1,255,255,255> ; Инициализация
            mov      ax,cur_point.x      ; Обращение к слову "x"
 
Если была определена вложенная структура, доступ к ее элементам осуществляется через еще один оператор «.» (точка).
  
 color      struc                         ; Определить структуру color.
 red        db       ?
 green      db       ?
 blue       db       ?
 color      ends
 
 point struc
 x          dw       0
 y          dw       0
 z          dw       0
 clr        color    <>
 point      ends
 
 cur_point  point    <>
            mov      cur_point.clr.red,al ; Обращение к красной компоненте
                                          ; цвета точки cur_point.
 
  

Сегменты

Каждая программа, написанная на любом языке программирования, состоит из одного или нескольких сегментов. Обычно область памяти, в которой находятся команды, называют сегментом кода, область памяти с данными — сегментом данных и область памяти, отведенную под стек, — сегментом стека. Разумеется, ассемблер позволяет изменять устройство программы как угодно — помещать данные в сегмент кода, разносить код на множество сегментов, помещать стек в один сегмент с данными или вообще использовать один сегмент для всего.
 Сегмент программы описывается директивами SEGMENT и ENDS.
 
  
 имя_сегмента   segment readonly выравн. тип разряд 'класс'
                    ...
 имя_сегмента   ends
 
Имя сегмента — метка, которая будет использоваться для получения сегментного адреса, а также для комбинирования сегментов в группы.
 Все пять операндов директивы SEGMENT необязательны.
 
READONLY. Если этот операнд присутствует, MASM выдаст сообщение об ошибке на все команды, выполняющие запись в данный сегмент. Другие ассемблеры этот операнд игнорируют.

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

 BYTE — с любого адреса;
  
 
 WORD — с четного адреса;
  
 
 DWORD — с адреса, кратного 4;
 
 
 PARA — с адреса, кратного 16 (граница параграфа);
  
 
 PAGE — с адреса, кратного 256.
 
По умолчанию используется выравнивание по границе параграфа.

Тип. Выбирает один из возможных типов комбинирования сегментов:

тип PUBLIC (иногда используется синоним MEMORY) означает, что все такие сегменты с одинаковым именем, но разными классами будут объединены в один;

тип STACK — то же самое, что и PUBLIC, но должен использоваться для сегментов стека, потому что при загрузке программы сегмент, полученный объединением всех сегментов типа STACK, будет использоваться как стек;

сегменты типа COMMON с одинаковым именем также объединяются в один, но не последовательно, а по одному и тому же адресу, следовательно, длина суммарного сегмента будет равна не сумме длин объединяемых сегментов, как в случае PUBLIC и STACK, а длине максимального. Таким способом иногда можно формировать оверлейные программы;

тип AT — выражение указывает, что сегмент должен располагаться по фиксированному абсолютному адресу в памяти. Результат выражения, использующегося в качестве операнда для AT, равен этому адресу, деленному на 16. Например: segment at 40h — сегмент, начинающийся по абсолютному адресу 0400h. Такие сегменты обычно содержат только метки, указывающие на области памяти, которые могут потребоваться программе;

PRIVATE (значение по умолчанию) — сегмент такого типа не объединяется с другими сегментами.

Разрядность. Этот операнд может принимать значения USE16 и USE32. Размер сегмента, описанного как USE16, не может превышать 64 Кб, и все команды и адреса в этом сегменте считаются 16-битными. В этих сегментах все равно можно применять команды, использующие 32-битные регистры или ссылающиеся на данные в 32-битных сегментах, но они будут использовать префикс изменения разрядности операнда или адреса и окажутся длиннее и медленнее. Сегменты USE32 могут занимать до 4 Гб, и все команды и адреса в них по умолчанию 32-битные. Если разрядность сегмента не указана, по умолчанию используется USE16 при условии, что перед директивой .MODEL не применялась директива задания допустимого набора команд .386 или старше.

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

Для обращения к любому сегменту следует сначала загрузить его сегментный адрес (или селектор в защищенном режиме) в какой-нибудь сегментный регистр. Если в программе определено много сегментов, удобно объединить несколько сегментов в группу, адресуемую с помощью одного сегментного регистра:

имя_группы group имя_сегмента...

Операнды этой директивы — список имен сегментов (или выражений, использующих оператор SEG), которые объединяются в группу. Имя группы теперь можно применять вместо имен сегментов для получения сегментного адреса и для директивы ASSUME.

assume регистр:связь...

Директива ASSUME указывает ассемблеру, с каким сегментом или группой сегментов связан тот или иной сегментный регистр. В качестве операнда «связь» могут использоваться имена сегментов, имена групп, выражения с оператором SEG или слово «NOTHING», означающее отмену действия предыдущей ASSUME для данного регистра. Эта директива не изменяет значений сегментных регистров, а только позволяет ассемблеру проверять допустимость ссылок и самостоятельно вставлять при необходимости префиксы переопределения сегментов, если они необходимы.

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

Директивы управления программным счетчиком

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

org выражение

Устанавливает значение программного счетчика. Директива ORG с операндом 100h обязательно используется при написании файлов типа COM, которые загружаются в память после блока параметров размером 100h.

even

Директива EVEN делает текущее значение счетчика кратным двум, вставляя команду NOP, если оно было нечетным. Это увеличивает скорость работы программы, так как для доступа к слову, начинающемуся с нечетного адреса, процессор должен считать два слова из памяти. Если при описании сегмента не использовалось выравнивание типа BYTE, счетчик в начале сегмента всегда четный.

align значение

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

Структуры IF.. THEN... ELSE

Это часто встречающаяся управляющая структура, передающая управление на один участок программы, если некоторое условие выполняется, и на другой, если оно не выполняется, записывается на ассемблере в следующем общем виде:
 
 ; набор команд, проверяющих условие
         Jcc        Else
 ; набор команд, соответствующих блоку THEN
         jmp        Endif
 Else:
 ; набор команд, соответствующих блоку ELSE
 Endif:
 
Для сложных условий часто оказывается, что одной командой условного перехода обойтись нельзя, так что реализация проверки может значительно увеличиться; например, следующую строку на языке С
  
 if (((х > у) && (z < t)) || (a != b)) c = d;
 
 
 можно представить на ассемблере как:
 
  
 ; проверка условия
         mov        ax,A
         cmp        ах,В
         jne        then           ; если а != b - условие выполнено
         mov        ах,X
         cmp        ax,Y
         jng        endif          ; если х <= у - условие не выполнено
         mov        ax,Z
         cmp        ах,Т
         jnl        endif          ; если z >= t - условие не выполнено
 then:                             ; условие выполняется
         mov        ax,D
         mov        С,ах
 endif:
 

Структуры CASE

Управляющая структура типа CASE проверяет значение некоторой переменной (или выражения) и передает управление на различные участки программы. Кажется очевидным, что эта структура должна реализовываться в виде серии структур IF... THEN... ELSE, как показано в примерах, где требовались различные действия в зависимости от значения нажатой клавиши.

Пусть переменная I принимает значения от 0 до 2, и в зависимости от значения надо выполнить процедуры case0, casel и case2:

 
         mov        ax,I
         cmp        ax,0           ; проверка на 0
         jne        not0
         call       case0
         jmp        endcase
 not0:   cmp        ax,1           ; проверка на 1
         jne        not1
         call       case1
         jmp        endcase
 not1:   cmp        ax,2           ; проверка на 2
         jne        not2
         call       case2
 not2:
 endcase:
 
Но ассемблер предоставляет более удобный способ реализации таких структур — таблицу переходов.
 
         mov        bx,I
         shl        bx,1      ; умножить ВХ на 2 (размер адреса
         ; в таблице переходов - 4 для 32-битных адресов)
         jmp        cs:jump_table[bx]       ; разумеется,
         ; в этом примере достаточно использовать call
 
 jump_table         dw    foo0,foo1,foo2    ; таблица переходов
 
 foo0:   call       case0
         jmp        endcase
 foo1:   call       case1
         jmp        endcase
 foo2:   call       case2
         jmp        endcase
 
Очевидно, что для большого числа значений переменной способ с таблицей переходов гораздо быстрее (не требуется многочисленных проверок), а если большая часть значений переменной — числа, следующие в точности друг за другом (так что в таблице переходов не окажется пустых участков), то эта реализация структуры CASE окажется еще и значительно меньше.

Конечные автоматы

Конечный автомат — процедура, которая помнит свое состояние и при обращении к ней выполняет различные действия для разных состояний. Например, рассмотрим процедуру, которая складывает регистры АХ и ВХ при первом вызове, вычитает при втором, умножает при третьем, делит при четвертом, снова складывает при пятом и т.д. Очевидная реализация, опять же, состоит в последовательности условных переходов:
 
 state              db    0
 state_machine:
         cmp        state,0
         jne        not_0
 ; состояние 0: сложение
         add        ax,bx
         inc        state
         ret
 not_0:  cmp        state,1
         jne        not_1
 ; состояние 1: вычитание
         sub        ax,bx
         inc        state
         ret
 not_1:  cmp        state,2
         jne        not_2
 ; состояние 2: умножение
         push       dx
         mul        bx
         pop        dx
         inc        state
         ret
 : состояние 3: деление
 not_2:  push       dx
         xor        dx,dx
         div        bx
         pop        dx
         mov        state,0
         ret
 
Оказывается, что, как и для CASE, в ассемблере есть средства для более эффективной реализации этой структуры. Это все тот же косвенный переход, использованный нами только что для CASE:
 
 state              dw    offset state_0
 state_machine:
         jmp        state
 
 state_0:
         add        ax,bx        ; состояние 0: сложение
         mov        state,offset state_1
         ret
 state_1:
         sub        ax,bx        ; состояние 1: вычитание
         mov        state,offset state_2
         ret
 state_2:
         push       dx           ; состояние 2: умножение
         mul        bx
         pop        dx
         mov        state,offset state_3
         ret
 state_3:
         push       dx           ; состояние З: деление
         xor        dx,dx
         div        bx
         рор        dx
         mov        state,offset state_0
         ret
 
Как и в случае с CASE, использование косвенного перехода приводит к тому, что не требуется никаких проверок и время выполнения управляющей структуры остается одним и тем же для четырех или четырех тысяч состояний.

Передача параметров

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

Параметры можно передавать с помощью одного из шести механизмов:

  
 по значению;
  
 по ссылке;
  
 по возвращаемому значению;
  
 по результату;
  
 по имени;
  
 отложенным вычислением.
  
 
 Параметры можно передавать в одном из пяти мест:
 
  
 в регистрах;
  
 в глобальных переменных;
  
 в стеке;
  
 в потоке кода;
  
 в блоке параметров.
  
Так что всего в ассемблере возможно 30 различных способов передачи параметров для процедур. Рассмотрим их по порядку.

Передача параметров по значению

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

Например, если параметры передаются в регистрах:

 
         mov        ax,word ptr value   ; сделать копию значения
         call       procedure           ; вызвать процедуру
 
Передача параметров по ссылке

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

 
         mov        ax,offset value
         call       procedure
 
Передача параметров по возвращаемому значению

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

 
         mov        global_variable,offset value
         call       procedure
         [...]
 procedure proc near
         mov        dx,global_variable
         mov        ax,word ptr [dx]
        (команды,  работающие с АХ в цикле десятки тысяч раз)
         mov        word ptr [dx],ax
 procedure endp
 
Передача параметров по результату

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

Передача параметров по имени

Это механизм, который используют макроопределения, директива EQU, а также, например, препроцессор С при обработке команды #define. При реализации этого механизма в компилирующем языке программирования (к которому относится и ассемблер) приходится заменять передачу параметра по имени другими механизмами при помощи, в частности, макроопределений.

Если определено макроопределение

 
 pass_by_name       macro  parameter1
         mov        ax,parameter1
 endm
 
то теперь в программе можно передавать параметр так:
  
         pass_by_name value
         call         procedure
 
Примерно так же поступают языки программирования высокого уровня, поддерживающие этот механизм: процедура получает адрес специальной функции-заглушки, которая вычисляет адрес передаваемого по имени параметра.

Передача параметров отложенным вычислением

Как и в предыдущем случае, здесь процедура получает адрес функции, вычисляющей значение параметра. Такой механизм удобен, если вычисление значения параметра требует много ресурсов или времени, например, если функция должна выбрать один из нескольких ходов при игре в шахматы, вычисление каждого параметра может занимать несколько минут. При передаче параметров отложенным вычислением функция получает адрес заглушки, которая при первом обращении к ней вычисляет значение параметра и сохраняет его во внутренней локальной переменной, а при дальнейших вызовах возвращает ранее вычисленное значение. Если процедуре вообще не потребуются значения части параметров (например, если первый же ход приводит к мату), то использование отложенных вычислений способствует значительному выигрышу. Этот механизм чаще всего применяется в системах искусственного интеллекта и операционных системах.

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

Передача параметров в регистрах

Если процедура получает небольшое число параметров, идеальным местом для их передачи оказываются регистры. Примерами использования этого метода могут служить практически все вызовы прерываний DOS и BIOS. Языки высокого уровня обычно используют регистр АХ (ЕАХ) для того, чтобы возвращать результат работы функции.

Передача параметров в глобальных переменных

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

Передача параметров в стеке

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

  
         push       parameter1       ; поместить параметр в стек
         push       parameter2
         call       procedure
         add        sp,4             ; освободить стек от параметров
         [...]
 procedure          proc  near
         push       bp
         mov        bp,sp
 (команды, которые могут использовать стек)
         mov        ax,[bp+4]        ; считать параметр 2.
 ; Его адрес в сегменте стека ВР + 4, потому что при выполнении
 ; команды CALL в стек поместили адрес возврата - 2 байта для процедуры
 ; типа NEAR (или 4 - для FAR), а потом еще и ВР - 2 байта
         mov        bx,[bp+6]        ; считать параметр 1
 (остальные команды)
         рор        bp
         ret
 procedure          endp
 
Параметры в стеке, адрес возврата и старое значение ВР вместе называются активационной записью функции.

Для удобства ссылок на параметры, переданные в стеке, внутри функции иногда используют директивы EQU, чтобы не писать каждый раз точное смещение параметра от начала активационной записи (то есть от ВР), например так:

 
         push       X
         push       Y
         push       Z
         call       xyzzy
         [...]
 xyzzy   proc       near
 xyzzy_z equ        [bp+8]
 xyzzy_y equ        [bp+6]
 xyzzy_x equ        [bp+4]
         push       bp
         mov        bp,sp
 (команды, которые могут использовать стек)
         mov        ax,xyzzy_x       ;считать параметр X
 (остальные команды)
         pop        bp
         ret        6
 xyzzy   endp
 
При внимательном анализе этого метода передачи параметров возникает сразу два вопроса: кто должен удалять параметры из стека, процедура или вызывающая ее программа, и в каком порядке помещать параметры в стек. В обоих случаях оказывается, что оба варианта имеют свои «за» и «против», так, например, если стек освобождает процедура (командой RET число_байтов), то код программы получается меньшим, а если за освобождение стека от параметров отвечает вызывающая функция, как в нашем примере, то становится возможным вызвать несколько функций с одними и теми же параметрами просто последовательными командами CALL. Первый способ, более строгий, используется при реализации процедур в языке Pascal, а второй, дающий больше возможностей для оптимизации, — в языке С. Разумеется, если передача параметров через стек применяется и для возврата результатов работы процедуры, из стека не надо удалять все параметры, но популярные языки высокого уровня не пользуются этим методом. Кроме того, в языке С параметры помещают в стек в обратном порядке (справа налево), так что становятся возможными функции с изменяемым числом параметров (как, например, printf — первый параметр, считываемый из [ВР+4], определяет число остальных параметров). Но подробнее о тонкостях передачи параметров в стеке рассказано далее, а здесь приведен обзор методов.

Передача параметров в потоке кода

В этом необычном методе передаваемые процедуре данные размещаются прямо в коде программы, сразу после команды CALL (как реализована процедура print в одной из стандартных библиотек процедур для ассемблера UCRLIB):

  
         call       print
         db         "This ASCIZ-line will be printed",0
         (следующая команда)
 
Чтобы прочитать параметр, процедура должна использовать его адрес, который автоматически передается в стеке как адрес возврата из процедуры. Разумеется, функция должна будет изменить адрес возврата на первый байт после конца переданных параметров перед выполнением команды RET. Например, процедуру print можно реализовать следующим образом:
 
 print   proc   near
         push       bp
         mov        bp,sp
         push       ax
         push       si
         mov        si,[bp+2]      ; прочитать адрес
                                   ; возврата/начала данных
         cld                       ; установить флаг направления
                                   ; для команды lodsb
 print_readchar:
         lodsb                     ; прочитать байт из строки,
         test       al,al          ; если это 0 (конец строки),
         jz         print_done     ; вывод строки закончен
         int        29h            ; вывести символ в AL на экран
         jmp        short print_readchar
 print_done:
         mov        [bp+2],si      ; поместить новый адрес возврата в стек
         pop        si
         pop        ax
         pop        bp
         ret
 print   endp
 
Передача параметров в потоке кода, так же как и передача параметров в стеке в обратном порядке (справа налево), позволяет передавать различное число параметров, но этот метод — единственный, позволяющий передать по значению параметр различной длины, что и продемонстрировал этот пример. Доступ к параметрам, переданным в потоке кода, несколько медленнее, чем к параметрам, переданным в регистрах, глобальных переменных или стеке, и примерно совпадает со следующим методом.

Передача параметров в блоке параметров

Блок параметров — это участок памяти, содержащий параметры, так же как и в предыдущем примере, но располагающийся обычно в сегменте данных. Процедура получает адрес начала этого блока при помощи любого метода передачи параметров (в регистре, в переменной, в стеке, в коде или даже в другом блоке параметров). В качестве примеров использования этого метода можно назвать многие функции DOS и BIOS, например поиск файла, использующий блок параметров DTA, или загрузка (и исполнение) программы, использующая блок параметров ЕРВ.

Локальные переменные

Часто процедурам требуются локальные переменные, которые не будут нужны после того, как процедура закончится. По аналогии с методами передачи параметров можно говорить о локальных переменных в регистрах — каждый регистр, который сохраняют при входе в процедуру и восстанавливают при выходе, фактически играет роль локальной переменной. Единственный недостаток регистров в роли локальных переменных — их слишком мало. Следующий вариант — хранение локальных данных в переменной в сегменте данных — удобен и быстр для большинства несложных ассемблерных программ, но процедуру, использующую этот метод, нельзя вызывать рекурсивно: такая переменная на самом деле является глобальной и находится в одном и том же месте в памяти для каждого вызова процедуры. Третий и наиболее распространенный способ хранения локальных переменных в процедуре — стек. Принято располагать локальные переменные в стеке сразу после сохраненного значения регистра ВР, так что на них можно ссылаться изнутри процедуры, как [ВР-2], [ВР-4], [ВР-б] и т.д.:
 
 foobar             proc   near
 foobar_x           equ    [bp+8]    ; параметры
 foobar_y           equ    [bp+6]
 foobar_z           equ    [bp+4]
 foobar_l           equ    [bp-2]    ; локальные переменные
 foobar_m           equ    [bp-4]
 foobar_n           equ    [bp-6]
 
         push       bp               ; сохранить предыдущий ВР
         mov        bp,sp            ; установить ВР для этой процедуры
         sub        sp,6             ; зарезервировать 6 байт для
                                     ; локальных переменных
 (тело процедуры)
         mov        sp,bp            ; восстановить SP, выбросив
                                     ; из стека все локальные переменные
         pop        bp               ; восстановить ВР вызвавшей процедуры
         ret        6                ; вернуться, удалив параметры из стека
 foobar  endp
 
Внутри процедуры foobar стек будет заполнен следующим образом (см. рис. 16).

Последовательности команд, используемые в начале и в конце таких процедур, оказались настолько часто применяемыми, что в процессоре 80186 были введены специальные команды ENTER и LEAVE, выполняющие эти же самые действия:

 
 foobar             proc    near
 foobar_x           equ     [bp+8]   ; параметры
 foobar_y           equ     [bp+6]
 foobar_z           equ     [bp+4]
 foobar_l           equ     [bp-2]   ; локальные
 foobar_m           equ     [bp-4]   ; переменные
 foobar_n           equ     [bp-6]
 
         enter      6,0              ; push bp
                                     ; mov bp,sp
                                     ; sub sp,6
 (тело процедуры)
         leave                       ; mov sp,bp
                                     ; pop bp
         ret        6                ; вернуться,
                                     ; удалив параметры
                                     ; из стека
 foobar  endp
 
Область в стеке, отводимая для локальных переменных вместе с активационной записью, называется стековым кадром.

Сортировки

Еще одна часто встречающаяся задача при программировании — сортировка данных. Все существующие алгоритмы сортировки можно разделить на сортировки перестановкой, в которых на каждом шаге алгоритма меняется местами пара чисел; сортировки выбором, в которых на каждом шаге выбирается наименьший элемент и дописывается в отсортированный массив; и сортировки вставлением, в которых элементы массива рассматривают последовательно и каждый вставляют на подходящее место в отсортированном массиве. Самая простая сортировка перестановкой — пузырьковая, в которой более легкие элементы «всплывают» к началу массива. Сначала второй элемент сравнивается с первым и, если нужно, меняется с ним местами. Затем третий элемент сравнивается со вторым и только в том случае, когда они переставляются, сравнивается с первым, и т.д. Этот алгоритм также является и самой медленной сортировкой — в худшем случае для сортировки массива N чисел потребуется N2/2 сравнений и перестановок, а в среднем — N2/4.

 
 ; Процедура bubble_sort
 ; сортирует массив слов методом пузырьковой сортировки
 ; ввод: DS:DI = адрес массива
 ;       DX = размер массива (в словах)
 bubble_sort        proc    near
         pusha
         cld
         cmp        dx,1
         jbe        sort_exit        ; выйти, если сортировать нечего
         dec        dx
 sb_loop1:
         mov        cx,dx            ; установить длину цикла
         xor        bx,bx            ; BX будет флагом обмена
         mov        si,di            ; SI будет указателем на
                                     ; текущий элемент
 sn_loop2:
         lodsw                       ; прочитать следующее слово
         cmp        ax,word ptr [si]
         jbe        no_swap          ; если элементы не
                                     ; в порядке,
         xchg       ax,word ptr [si] ; поменять их местами
         mov        word ptr [si-2],ax
         inc        bx               ; и установить флаг в 1,
 no_swap:
         loop       sn_loop2
         cmp        bx,0             ; если сортировка не закончилась,
         jne        sn_loop1         ; перейти к следующему элементу
 sort_exit:
         popa
         ret
 bubble_sort        endp
 
Пузырьковая сортировка осуществляется так медленно потому, что сравнения выполняются лишь между соседними элементами. Чтобы получить более быстрый метод сортировки перестановкой, следует выполнять сравнение и перестановку элементов, отстоящих далеко друг от друга. На этой идее основан алгоритм, который называется «быстрая сортировка». Он работает следующим образом: делается предположение, что первый элемент является средним по отношению к остальным. На основе такого предположения все элементы разбиваются на две группы — больше и меньше предполагаемого среднего. Затем обе группы отдельно сортируются таким же методом. В худшем случае быстрая сортировка массива из N элементов требует N2 операций, но в среднем случае — только 2n*log2n сравнений и еще меньшее число перестановок.
 
 ; Процедура quick_sort
 ; сортирует массив слов методом быстрой сортировки
 ; ввод: DS:BX = адрес массива
 ;       DX = число элементов массива
 quicksort       proc    near
         cmp     dx,1             ; Если число элементов 1 или 0,
         jle     qsort_done       ; то сортировка уже закончилась
         xor     di,di            ; индекс для просмотра сверху (DI = 0)
         mov     si,dx            ; индекс для просмотра снизу (SI = DX)
         dec     si    ; SI = DX-1, так как элементы нумеруются с нуля,
         shl     si,1  ; и умножить на 2, так как это массив слов
         mov     ax,word ptr [bx] ; AX = элемент X1, объявленный средним
 step_2:         ; просмотр массива снизу, пока не встретится
         ; элемент, меньший или равный Х1
         cmp     word ptr [bx][si],ax   ; сравнить XDI и Х1
         jle     step_3          ; если XSI больше,
         sub     si,2            ; перейти к следующему снизу элементу
         jmp     short step_2    ; и продолжить просмотр
 step_3:         ; просмотр массива сверху, пока не встретится
                 ; элемент меньше Х1 или оба просмотра не придут
                 ; в одну точку
                 cmp     si,di           ; если просмотры встретились,
                 je      step_5          ; перейти к шагу 5,
                 add     di,2            ; иначе: перейти
                                         ; к следующему сверху элементу,
                 cmp     word ptr [bx][di],ax ; если он меньше Х1,
                 jl      step_3          ; продолжить шаг 3
 steр_4:         ; DI указывает на элемент, который не должен быть
                 ; в верхней части, SI указывает на элемент,
                 ; который не должен быть в нижней. Поменять их местами
                 mov     cx,word ptr [bx][di]        ; CX = XDI
                 xchg    cx,word ptr [bx][si]        ; CX = XSI, XSI = XDI
                 mov     word ptr [bx][di],cx        ; XDI = CX
                 jmp     short step_2
 step_5:         ; Просмотры встретились. Все элементы в нижней
                 ; группе больше X1, все элементы в верхней группе
                 ; и текущий - меньше или равны Х1 Осталось
                 ; поменять местами Х1 и текущий элемент:
                 xchg    ах,word ptr [bx][di]        ; АХ = XDI, XDI = X1
                 mov     word ptr [bx],ax            ; X1 = AX
 ; теперь можно отсортировать каждую из полученных групп
                 push    dx
                 push    di
                 push    bx
 
                 mov     dx,di       ; длина массива X1...XDI-1
                 shr     dx,1        ; в DX
                 call    quick_sort  ; сортировка
 
                 pop     bx
                 pop     di
                 pop     dx
 
                 add     bx,di       ; начало массива XDI+1...XN
                 add     bx,2        ; в BX
                 shr     di,1        ; длина массива XDI+1...XN
                 inc     di
                 sub     dx,di       ; в DX
                 call    quicksort   ; сортировка
 qsort_done:     ret
 quicksort       endp
 
Кроме того, что быстрая сортировка — самый известный пример алгоритма, использующего рекурсию, то есть вызывающего самого себя, это еще и самая быстрая из сортировок «на месте», то есть сортировка, использующая только ту память, в которой хранятся элементы сортируемого массива. Можно доказать, что сортировку нельзя выполнить быстрее, чем за n*log2n операций, ни в худшем, ни в среднем случаях, и быстрая сортировка достаточно хорошо приближается к этому пределу в среднем случае. Сортировки, достигающие теоретического предела, тоже существуют — это сортировки турнирным выбором и сортировки вставлением в сбалансированные деревья, но для их работы требуется резервирование дополнительной памяти, так что, например, работа со сбалансированными деревьями будет происходить медленно из-за дополнительных затрат на поддержку сложных структур данных в памяти.

Рассмотрим в качестве примера самый простой вариант сортировки вставлением, использующий линейный поиск и затрачивающий порядка n2/2 операций. Ее так же просто реализовать, как и пузырьковую сортировку, и она тоже имеет возможность выполняться «на месте». Кроме того, из-за высокой оптимальности кода этой процедуры она может оказываться даже быстрее рассмотренной нами «быстрой» сортировки на подходящих массивах.

  
 ; Процедура linear_selection_sort
 ; сортирует массив слов методом сортировки линейным выбором
 ; Ввод: DS:SI (и ES:SI) = адрес массива
 ;       DX = число элементов в массиве
 
 do_swap:     lea    bx,word ptr [di-2]
              mov    ax, word ptr [bx]     ; новое минимальное число
              dec    cx          ; если поиск минимального закончился,
              jcxz   tail        ; перейти к концу
 loop1:       scasw              ; сравнить минимальное в АХ
                                 ; со следующим элементом массива
              ja     do_swap     ; если найденный элемент
                                 ; еще меньше - выбрать
                                 ; его как минимальный
              loop   loop1       ; продолжить сравнения
                                 ; с минимальным в АХ
 tail:.       xchg   ax,word ptr [si-2]   ; обменять минимальный элемент
              mov    word ptr [bx],ax     ; с элементом, находящимся в начале
                                          ; массива
 linear_selection_sort   proc   near      ; точка входа в процедуру
              mov    bx,si       ; BX содержит адрес
                                 ; минимального элемента
              lodsw              ; пусть элемент, адрес
                                 ; которого был в SI, минимальный,
              mov    di,si       ; DI - адрес элемента, сравниваемого
                                 ; с минимальным
              dec    dx          ; надо проверить DX-1 элементов массива
              mov    cx,dx
              jg     loop1       ; переход на проверку, если DX > 1
              ret
 linear_selection_sort    endp
 

Обработчики прерываний

Когда в реальном режиме выполняется команда INT, управление передается по адресу, который считывается из специального массива, таблицы векторов прерываний, начинающегося в памяти по адресу 0000h:0000h. Каждый элемент этого массива представляет собой дальний адрес обработчика прерывания в формате сегмент:смещение или 4 нулевых байта, если обработчик не установлен. Команда INT помещает в стек регистр флагов и дальний адрес возврата, поэтому, чтобы завершить обработчик, надо выполнить команды popf и retf или одну команду iret, которая в реальном режиме полностью им аналогична.
  
 ; Пример обработчика программного прерывания
 int_handler     proc     far
                 mov      ax,0
                 iret
 int_handler     endp
 
После того как обработчик написан, следующий шаг — привязка его к выбранному номеру прерывания. Это можно сделать, прямо записав его адрес в таблицу векторов прерываний, например так:
  
                 push     0         ; сегментный адрес таблицы
                                    ; векторов прерываний
                 pop      es        ; в ES
                 pushf              ; поместить регистр флагов в стек
                 cli                ; запретить прерывания
 ; (чтобы не произошло аппаратного прерывания между следующими
 ; командами, обработчик которого теоретически может вызвать INT 87h
 ; в тот момент, когда смещение уже будет записано, а сегментный
 ; адрес еще нет, что приведет к передаче управления
 ; в неопределенную область памяти)
 ; поместить дальний адрес обработчика int_handler в таблицу
 ; векторов прерываний, в элемент номер 87h 
 ; (одно из неиспользуемых прерываний)
                 mov      word ptr es:[87h*4], offset int_handler
                 mov      word ptr es:[87h*4+2], seg int_handler
                 popf               ; восстановить исходное значение флага IF
 
Теперь команда INT 87h будет вызывать наш обработчик, то есть приводить к записи 0 в регистр АХ.

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

  
                 push     0
                 pop      es
 ; скопировать адрес предыдущего обработчика в переменную old_handler
                 mov      eax,dword ptr es:[87h*4]
                 mov      dword ptr old_handler,eax
 ; установить наш обработчик
                 pushf
                 cli
                 mov      word ptr es:[87h*4], offset int_handler
                 mov      word ptr es:[87h*4+2], seg int_handler
                 popf
 ; тело программы
 [...]
 ; восстановить предыдущий обработчик
                 push     0
                 pop      es
                 pushf
                 cli
                 mov      eax,word ptr old_handler
                 mov      word ptr es:[87h*4],eax
                 popf
 
Хотя прямое изменение таблицы векторов прерываний и кажется достаточно удобным, все-таки это не лучший подход к установке обработчика прерывания, и пользоваться им следует только в случаях крайней необходимости, например внутри обработчиков прерываний. Для обычных программ DOS предоставляет две системные функции: 25h и 35h — установить и считать адрес обработчика прерывания, которые и рекомендуются к использованию в обычных условиях:
  
 ; скопировать адрес предыдущего обработчика в переменную old_handler
                 mov      ax,3587h       ; АН = 35h, AL = номер прерывания
                 int      21h            ; функция DOS: считать
                                         ; адрес обработчика прерывания
                 mov      word ptr old_handler,bx    ; возвратить
                                                     ; смещение в ВХ
                 mov      word ptr old_handler+2,es  ; и сегментный
                                                     ; адрес в ES,
 ; установить наш обработчик
                 mov      ax,2587h       ; АН = 25h, AL = номер прерывания
                 mov      dx,seg int_handler         ; сегментный адрес
                 mov      ds,dx                      ; в DS
                 mov      dx,offset int_handler      ; смещение в DX
                 int      21h                        ; функция DOS: установить
                                                     ; обработчик
 ; (не забывайте, что ES изменился после вызова функции 35h!)
 [...]
 ; восстановить предыдущий обработчик
                 lds      dx,old_handler ; сегментный адрес в DS и смещение в DX
                 mov      ax,2587h       ; АН = 25h, AL = номер прерывания
                 int      21h            ; установить обработчик
 
Обычно обработчики прерываний используют для того, чтобы обрабатывать прерывания от внешних устройств или чтобы обслуживать запросы других программ. Эти возможности рассмотрены далее, а здесь показано, как можно использовать обычный обработчик прерывания (или, в данном случае, исключения ошибки) для того, чтобы быстро найти минимум и максимум в большом массиве данных.
  
 ; Процедура minmax
 ; находит минимальное и максимальное значения в массиве слов
 ; Ввод: DS:BX = адрес начала массива
 ;       СХ = число элементов в массиве
 ; Вывод:
 ;       АХ = максимальный элемент
         ВХ = минимальный элемент
 minmax          proc     near
 ; установить наш обработчик прерывания 5
                 push     0
                 pop      es
                 mov      еах,dword ptr es:[5*4]
                 mov      dword ptr old_int5,eax
                 mov      word ptr es:[5*4],offset int5_handler
                 mov      word ptr es:[5*4]+2,cs
 ; инициализировать минимум и максимум первым элементом массива
                 mov      ax,word ptr [bx]
                 mov      word ptr lower_bound,ax
                 mov      word ptr upper_bound,ax
 ; обработать массив
                 mov      di,2            ; начать со второго элемента
 bcheck:
                 mov      ax,word ptr [bx][di] ; считать элемент в АХ
                 bound    ax,bounds       ; команда BOUND вызывает
                                          ; исключение - ошибку 5,
 ; если АХ не находится в пределах lower_bound/upper_bound
                 add      di,2            ; следующий элемент
                 loop     bcheck          ; цикл на все элементы
 ; восстановить предыдущий обработчик
                 mov      eax,dword ptr old_int5
                 mov      dword ptr es:[5*4],eax
 ; вернуть результаты
                 mov      ax,word ptr upper_bound
                 mov      bx,word ptr lower_bound
                 ret
 
 bounds:
 lower_bound     dw       ?
 upper_bound     dw       ?
 old_int5        dd       ?
 
 ; обработчик INT 5 для процедуры minmax
 ; сравнить АХ со значениями upper_bound и lower_bound и копировать
 ; AX в один из них, обработчик не обрабатывает конфликт между
 ; исключением BOUND и программным прерыванием распечатки экрана INT 5.
 ; Нажатие клавиши PrtScr в момент работы процедуры minmax приведет
 ; к ошибке. Чтобы это исправить, можно, например, проверять байт,
 ; на который указывает адрес возврата, если это CDh
 ; (код команды INT), то обработчик был вызван как INT 5
 int5_handler    proc     far
                 cmp      ax,word ptr lower_bound  ; сравнить АХ с нижней границей,
                 jl       its_lower                ; если не меньше -
                                                   ; это было нарушение
                 mov      word ptr upper_bound,ax  ; верхней границы
                 iret
 its_lower:
                 mov      word ptr lower_bound,ax  ; если это было нарушение
                 iret                              ; нижней границы
 int5_handler    endp
 minmax          endp
 

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

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

#DE (деление на ноль) — INT 0 — ошибка, возникающая при переполнении и делении на ноль. Как для любой ошибки, адрес возврата указывает на ошибочную команду.

#DB (прерывание трассировки) — INT 1 — ловушка, возникающая после выполнения каждой команды, если флаг TF установлен в 1. Используется отладчиками, действующими в реальном режиме.

#OF (переполнение) — INT 4 — ловушка, возникающая после выполнения команды INTO, если флаг OF установлен.

#ВС (переполнение при BOUND) — INT 5 — уже рассмотренная нами ошибка, возникающая при выполнении команды BOUND.

#UD (недопустимая команда) — INT 6 — ошибка, возникающая при попытке выполнить команду, отсутствующую на данном процессоре.

#NM (сопроцессор отсутствует) — INT 7 — ошибка, возникающая при попытке выполнить команду FPU, если FPU отсутствует.

Обработчики прерываний

Когда в реальном режиме выполняется команда INT, управление передается по адресу, который считывается из специального массива, таблицы векторов прерываний, начинающегося в памяти по адресу 0000h:0000h. Каждый элемент этого массива представляет собой дальний адрес обработчика прерывания в формате сегмент:смещение или 4 нулевых байта, если обработчик не установлен. Команда INT помещает в стек регистр флагов и дальний адрес возврата, поэтому, чтобы завершить обработчик, надо выполнить команды popf и retf или одну команду iret, которая в реальном режиме полностью им аналогична.
 
 ; Пример обработчика программного прерывания
 int_handler     proc     far
                 mov      ax,0
                 iret
 int_handler     endp
 
После того как обработчик написан, следующий шаг — привязка его к выбранному номеру прерывания. Это можно сделать, прямо записав его адрес в таблицу векторов прерываний, например так:
 
  
                 push     0         ; сегментный адрес таблицы
                                 ; векторов прерываний
                 pop      es        ; в ES
                 pushf              ; поместить регистр флагов в стек
                 cli                ; запретить прерывания
 ; (чтобы не произошло аппаратного прерывания между следующими
 ; командами, обработчик которого теоретически может вызвать INT 87h
 ; в тот момент, когда смещение уже будет записано, а сегментный
 ; адрес еще нет, что приведет к передаче управления
 ; в неопределенную область памяти)
 ; поместить дальний адрес обработчика int_handler в таблицу
 ; векторов прерываний, в элемент номер 87h 
 ; (одно из неиспользуемых прерываний)
                 mov      word ptr es:[87h*4], offset int_handler
                 mov      word ptr es:[87h*4+2], seg int_handler
                 popf               ; восстановить исходное значение флага IF
 
Теперь команда INT 87h будет вызывать наш обработчик, то есть приводить к записи 0 в регистр АХ.

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

 
  
                 push     0
                 pop      es
 ; скопировать адрес предыдущего обработчика в переменную old_handler
                 mov      eax,dword ptr es:[87h*4]
                 mov      dword ptr old_handler,eax
 ; установить наш обработчик
                 pushf
                 cli
                 mov      word ptr es:[87h*4], offset int_handler
                 mov      word ptr es:[87h*4+2], seg int_handler
                 popf
 ; тело программы
 [...]
 ; восстановить предыдущий обработчик
                 push     0
                 pop      es
                 pushf
                 cli
                 mov      eax,word ptr old_handler
                 mov      word ptr es:[87h*4],eax
                 popf
 
Хотя прямое изменение таблицы векторов прерываний и кажется достаточно удобным, все-таки это не лучший подход к установке обработчика прерывания, и пользоваться им следует только в случаях крайней необходимости, например внутри обработчиков прерываний. Для обычных программ DOS предоставляет две системные функции: 25h и 35h — установить и считать адрес обработчика прерывания, которые и рекомендуются к использованию в обычных условиях:
 
  ; скопировать адрес предыдущего обработчика в переменную old_handler
                 mov      ax,3587h       ; АН = 35h, AL = номер прерывания
                 int      21h            ; функция DOS: считать
                                         ; адрес обработчика прерывания
                 mov      word ptr old_handler,bx    ; возвратить
                                                     ; смещение в ВХ
                 mov      word ptr old_handler+2,es  ; и сегментный
                                                     ; адрес в ES,
 ; установить наш обработчик
                 mov      ax,2587h       ; АН = 25h, AL = номер прерывания
                 mov      dx,seg int_handler         ; сегментный адрес
                 mov      ds,dx                      ; в DS
                 mov      dx,offset int_handler      ; смещение в DX
                 int      21h                        ; функция DOS: установить
                                                     ; обработчик
 ; (не забывайте, что ES изменился после вызова функции 35h!)
 [...]
 ; восстановить предыдущий обработчик
                 lds      dx,old_handler ; сегментный адрес в DS и смещение в DX
                 mov      ax,2587h       ; АН = 25h, AL = номер прерывания
                 int      21h            ; установить обработчик
 
Обычно обработчики прерываний используют для того, чтобы обрабатывать прерывания от внешних устройств или чтобы обслуживать запросы других программ. Эти возможности рассмотрены далее, а здесь показано, как можно использовать обычный обработчик прерывания (или, в данном случае, исключения ошибки) для того, чтобы быстро найти минимум и максимум в большом массиве данных.
  
 ; Процедура minmax
 ; находит минимальное и максимальное значения в массиве слов
 ; Ввод: DS:BX = адрес начала массива
 ;       СХ = число элементов в массиве
 ; Вывод:
 ;       АХ = максимальный элемент
         ВХ = минимальный элемент
 minmax          proc     near
 ; установить наш обработчик прерывания 5
                 push     0
                 pop      es
                 mov      еах,dword ptr es:[5*4]
                 mov      dword ptr old_int5,eax
                 mov      word ptr es:[5*4],offset int5_handler
                 mov      word ptr es:[5*4]+2,cs
 ; инициализировать минимум и максимум первым элементом массива
                 mov      ax,word ptr [bx]
                 mov      word ptr lower_bound,ax
                 mov      word ptr upper_bound,ax
 ; обработать массив
                 mov      di,2            ; начать со второго элемента
 bcheck:
                 mov      ax,word ptr [bx][di] ; считать элемент в АХ
                 bound    ax,bounds       ; команда BOUND вызывает
                                          ; исключение - ошибку 5,
 ; если АХ не находится в пределах lower_bound/upper_bound
                 add      di,2            ; следующий элемент
                 loop     bcheck          ; цикл на все элементы
 ; восстановить предыдущий обработчик
                 mov      eax,dword ptr old_int5
                 mov      dword ptr es:[5*4],eax
 ; вернуть результаты
                 mov      ax,word ptr upper_bound
                 mov      bx,word ptr lower_bound
                 ret
 
 bounds:
 lower_bound     dw       ?
 upper_bound     dw       ?
 old_int5        dd       ?
 
 ; обработчик INT 5 для процедуры minmax
 ; сравнить АХ со значениями upper_bound и lower_bound и копировать
 ; AX в один из них, обработчик не обрабатывает конфликт между
 ; исключением BOUND и программным прерыванием распечатки экрана INT 5.
 ; Нажатие клавиши PrtScr в момент работы процедуры minmax приведет
 ; к ошибке. Чтобы это исправить, можно, например, проверять байт,
 ; на который указывает адрес возврата, если это CDh
 ; (код команды INT), то обработчик был вызван как INT 5
 int5_handler    proc     far
                 cmp      ax,word ptr lower_bound  ; сравнить АХ с нижней границей,
                 jl       its_lower                ; если не меньше -
                                                   ; это было нарушение
                 mov      word ptr upper_bound,ax  ; верхней границы
                 iret
 its_lower:
                 mov      word ptr lower_bound,ax  ; если это было нарушение
                 iret                              ; нижней границы
 int5_handler    endp
 minmax          endp
 
Разумеется, вызов исключения при ошибке занимает много времени, но, если массив достаточно большой и неупорядоченный, значительная часть проверок будет происходить без ошибок и быстро.

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

#DE (деление на ноль) — INT 0 — ошибка, возникающая при переполнении и делении на ноль. Как для любой ошибки, адрес возврата указывает на ошибочную команду.

#DB (прерывание трассировки) — INT 1 — ловушка, возникающая после выполнения каждой команды, если флаг TF установлен в 1. Используется отладчиками, действующими в реальном режиме.

#OF (переполнение) — INT 4 — ловушка, возникающая после выполнения команды INTO, если флаг OF установлен.

#ВС (переполнение при BOUND) — INT 5 — уже рассмотренная нами ошибка, возникающая при выполнении команды BOUND.

#UD (недопустимая команда) — INT 6 — ошибка, возникающая при попытке выполнить команду, отсутствующую на данном процессоре.

#NM (сопроцессор отсутствует) — INT 7 — ошибка, возникающая при попытке выполнить команду FPU, если FPU отсутствует.

Прерывания от внешних устройств

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

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

IRQ0 (INT 8) — прерывание системного таймера. Это прерывание вызывается 18,2 раза в секунду. Стандартный обработчик этого прерывания вызывает INT 1Ch при каждом вызове, так что, если программе необходимо только регулярно получать управление, а не перепрограммировать таймер, рекомендуется использовать прерывание 1Ch.

IRQ1 (INT 9) — прерывание клавиатуры. Это прерывание вызывается при каждом нажатии и отпускании клавиши на клавиатуре. Стандартный обработчик этого прерывания выполняет довольно много функций, начиная с перезагрузки по Ctrl-Alt-Del и заканчивая помещением кода клавиши в буфер клавиатуры BIOS.

IRQ2 — к этому входу на первом контроллере прерываний подключены аппаратные прерывания IRQ8 – IRQ15, но многие BIOS перенаправляют IRQ9 на INT 0Ah.

IRQ8 (INT 70h) — прерывание часов реального времени. Это прерывание вызывается часами реального времени при срабатывании будильника и если они установлены на генерацию периодического прерывания (в последнем случае IRQ8 вызывается 1024 раза в секунду).

IRQ9 (INT 0Ah или INT 71h) — прерывание обратного хода луча. Вызывается некоторыми видеоадаптерами при обратном ходе луча. Часто используется дополнительными устройствами (например, звуковыми картами, SCSI-адаптерами и т.д.).

IRQ10 (INT 72h) — используется дополнительными устройствами.

IRQ11 (INT 73h) — используется дополнительными устройствами.

IRQ12 (INT 74h) — мышь на системах PS используется дополнительными устройствами.

IRQ13 (INT 02h или INT 75h) — ошибка математического сопроцессора. По умолчанию это прерывание отключено как на FPU, так и на контроллере прерываний.

IRQ14 (INT 76h) — прерывание первого IDE-контроллера «операция завершена».

IRQ15 (INT 77h) — прерывание второго IDE-контроллера «операция завершена».

IRQ3 (INT 0Bh) — прерывание последовательного порта COM2 вызывается, если порт COM2 получил данные.

IRQ4 (INT 0Ch) — прерывание последовательного порта СОМ1 вызывается, если порт СОМ1 получил данные.

IRQ5 (INT 0Dh) — прерывание LPT2 используется дополнительными устройствами.

IRQ6 (INT 0Eh) — прерывание дисковода «операция завершена».

IRQ7 (INT 0Fh) — прерывание LPT1 используется дополнительными устройствами.

Самые полезные для программ аппаратные прерывания — прерывания системного таймера и клавиатуры. Так как их стандартные обработчики выполняют множество функций, от которых зависит работа системы, их нельзя заменять полностью, как мы делали это с обработчиком INT 5. Следует обязательно вызвать предыдущий обработчик, передав ему управление следующим образом (если его адрес сохранен в переменной old_handler, как в предыдущих примерах):

  
                 pushf
                 call     old_handler
 
Эти две команды выполняют действие, аналогичное команде INT (сохранить флаги в стеке и передать управление подобно команде call), так что, когда обработчик завершится командой IRET, управление вернется в нашу программу. Так удобно вызывать предыдущий обработчик в начале собственного. Другой способ — простая команда jmp:

jmp cs:old_handler

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

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

  
 ; timer.asm
 ; демонстрация перехвата прерывания системного таймера: 
 ; вывод текущего времени
 ; в левом углу экрана
         .model     tiny
         .code
         .186                        ; для pusha/popa и сдвигов
         org        100h
 start   proc       near
 ; сохранить адрес предыдущего обработчика прерывания 1Ch
         mov        ax,351Ch         ; АН = 35h, AL = номер прерывания
         int        21h   ; функция DOS: определить адрес обработчика
         mov        word ptr old_int1Ch,bx   ; прерывания
         mov        word ptr old_int1Ch+2,es ; (возвращается в ES:BX)
 ; установить наш обработчик
         mov        ax,251Ch         ; АН = 25h, AL = номер прерывания
         mov        dx,offset int1Ch_handler ; DS:DX - адрес обработчика
         int        21h              ; установить обработчик прерывания 1Ch
 
 ; здесь размещается собственно программа, например вызов command.com
         mov        ah,1
         int        21h              ; ожидание нажатия на любую клавишу
 ; конец программы
 
 ; восстановить предыдущий обработчик прерывания 1Ch
         mov        ax,251Ch         ; АН = 25h, AL = номер прерывания
         mov        dx,word ptr old_int1Ch+2
         mov        ds,dx
         mov        dx,word ptr cs:old_int1Ch ; DS:DX - адрес обработчика
         int        21h
 
         ret
 
 old_int1Ch       dd    ?   ; здесь хранится адрес предыдущего обработчика
 start_position   dw    0   ; позиция на экране, 
                            ; в которую выводится текущее время
 start   endp
 
 ; обработчик для прерывания 1Ch
 ; выводит текущее время в позицию start_position на экране
 ; (только в текстовом режиме)
 int1Ch_handler     proc    far
         pusha                       ; обработчик аппаратного прерывания
         push       es               ; должен сохранять ВСЕ регистры
         push       ds
         push       cs        ; на входе в обработчик известно только
         pop        ds               ; значение регистра CS
         mov        ah,02h           ; Функция 02h прерывания 1Ah:
         int        1Ah              ; чтение времени из RTC,
         jc         exit_handler     ; если часы заняты - в другой раз
 
 ; AL = час в BCD-формате
         call       bcd2asc                     ; преобразовать в ASCII,
         mov        byte ptr output_line[2],ah  ; поместить их в
         mov        byte ptr output_line[4],al  ; строку output_line
 
         mov        al,cl                       ; CL = минута в BCD-формате
         call       bcd2asc
         mov        byte ptr output_line[10],ah
         mov        byte ptr output_line[12],al
 
         mov        al,dh                       ; DH = секунда в BCD-формате
         call       bcd2asc
         mov        byte ptr output_line[16],ah
         mov        byte ptr output_line[18],al
 
         mov        cx,output_line_l ; число байт в строке - в СХ
         push       0B800h
         pop        es                          ; адрес в видеопамяти
         mov        di,word ptr start_position  ; в ES:DI
         mov        si,offset output_line       ; адрес строки в DS:SI
         cld
         rep        movsb                       ; скопировать строку
 exit_handler:
         pop        ds                          ; восстановить все регистры
         pop        es
         popa
         jmp        cs:old_int1Ch    
         ; передать управление предыдущему обработчику
 
 ; процедура bcd2asc
 ; преобразует старшую цифру упакованного BCD-числа из AL 
 ; в ASCII-символ,
 ; который будет помещен в АН, а младшую цифру - в ASCII-символ в AL
 bcd2asc            proc    near
         mov        ah,al
         and        al,0Fh           ; оставить младшие 4 бита в AL
         shr        ah,4             ; сдвинуть старшие 4 бита в АН
         or         ах,3030h         ; преобразовать в ASCII-символы
         ret
 bcd2asc            endp
 
 ; строка " 00h 00:00 " с атрибутом 1Fh (белый на синем) 
 ; после каждого символа
 output_line        db    ' ',1Fh,'0',1Fh,'0',1Fh,'h',1Fh
                    db    ' ',1Fh,'0',1Fh,'0',1Fh,':',1Fh
                    db    '0',1Fh,'0',1Fh,' ',1Fh
 output_line_l      equ   $ - output_line
 
 int1Ch_handler     endp
 
         end        start
 
Если в этом примере вместо ожидания нажатия на клавишу поместить какую-нибудь программу, работающую в текстовом режиме, например tinyshell из главы 1.3, она выполнится как обычно, но в правом верхнем углу будет постоянно показываться текущее время, то есть такая программа будет осуществлять два действия одновременно. Именно для этого и применяется механизм аппаратных прерываний — они позволяют процессору выполнять одну программу, в то время как отдельные программы следят за временем, считывают символы из клавиатуры и помещают их в буфер, получают и передают данные через последовательные и параллельные порты и даже обеспечивают многозадачность, переключая процессор между разными задачами по прерыванию системного таймера.

Разумеется, обработка прерываний не должна занимать много времени: если прерывание происходит достаточно часто (например, прерывание последовательного порта может происходить 28 800 раз в секунду), его обработчик обязательно должен выполняться за более короткое время. Если, например, обработчик прерывания таймера будет выполняться 1/32,4 секунды, то есть половину времени между прерываниями, вся система будет работать в два раза медленнее. А если еще одна программа с таким же долгим обработчиком перехватит это прерывание, система остановится совсем. Именно поэтому обработчики прерываний принято писать исключительно на ассемблере.

Последовательный порт

Каждый из последовательных портов обменивается данными с процессором через набор портов ввода-вывода: СОМ1 = 03F8h – 03FFh, COM2 = 02F8h – 02FFh, COM3 = 03E8H – 03EFh и COM4 = 02E8h – 02EFh. Имена портов СОМ1 – COM4 на самом деле никак не зафиксированы. BIOS просто называет порт СОМ1, адрес которого (03F8h по умолчанию) записан в области данных BIOS по адресу 0040h:0000h. Точно так же порт COM2, адрес которого записан по адресу 0040h:0002h, COM3 — 0040h:0004h и COM4 — 0040h:0006h. Рассмотрим назначение портов ввода-вывода на примере 03F8h – 03FFh.

03F8h для чтения и записи — если старший бит регистра управления линией = 0, это — регистр передачи данных (THR или RBR). Передача и прием данных через последовательный порт соответствуют записи и чтению именно в этот порт.

03F8h для чтения и записи — если старший бит регистра управления линией = 1, это — младший байт делителя частоты порта.

03F9h для чтения и записи — если старший бит регистра управления линией = 0, это — регистр разрешения прерываний (IER):

бит 3: прерывание по изменению состояния модема

бит 2: прерывание по состоянию BREAK или ошибке

бит 1: прерывание, если буфер передачи пуст

бит 0: прерывание, если пришли новые данные

03F9h для чтения и записи — если старший бит регистра управления линией = 1, это — старший байт делителя частоты порта. Значение скорости порта определяется по значению делителя частоты

03FAh для чтения — регистр идентификации прерывания. Содержит информацию о причине прерывания для обработчика:

биты 7 – 6: 00 — FIFO отсутствует, 11 — FIFO присутствует

бит 3: тайм-аут FIFO приемника

биты 2 – 1: тип произошедшего прерывания:

11 — состояние BREAK или ошибка. Сбрасывается после чтения из 03FDh

10 — пришли данные. Сбрасывается после чтения из 03F8h

01 — буфер передачи пуст. Сбрасывается после записи в 03F8h

00 — изменилось состояние модема. Сбрасывается после чтения из 03FEh

бит 0: 0, если произошло прерывание, 1, если нет

03FAh для записи — регистр управления FIFO (FCR)

биты 7 – 6: порог срабатывания прерывания о приеме данных

00 — 1 байт

01 — 4 байта

10 — 8 байт

11 — 16 байт

бит 2 — очистить FIFO приемника

бит 1 — очистить FIFO передатчика

бит 0 — включить режим работы через FIFO

03FBh для чтения и записи — регистр управления линией (LCR)

бит 7: если 1 — порты 03F8h и 03F9H работают, как делитель частоты порта

бит 6: состояние BREAK — порт непрерывно посылает нули

биты 5 – 3: четность:

? ? 0 — без четности

0 0 1 — контроль на четность

0 1 1 — контроль на нечетность

1 0 1 — фиксированная четность 1

1 1 1 — фиксированная четность 0

? ? 1 — программная (не аппаратная) четность

бит 2: число стоп-бит:

0 — 1 стоп-бит

1 — 2 стоп-бита для 6-, 7-, 8-битных, 1,5 стоп-бита для 5-битных слов

биты 1 – 0: длина слова

00 — 5 бит

01 — 6 бит

10 — 7 бит

11 — 8 бит

03FBH для чтения и записи — регистр управления модемом (MCR)

бит 4: диагностика (выход СОМ-порта замыкается на вход)

бит 3: линия OUT2 — должна быть 1, чтобы работали прерывания

бит 2: линия OUT1 — должна быть 0

бит 1: линия RTS

бит 0: линия DTR

03FCH для чтения — регистр состояния линии (LSR)

бит 6: регистр сдвига передатчика пуст

бит 5: регистр хранения передатчика пуст — можно писать в 03F8h

бит 4: обнаружено состояние BREAK (строка нулей длиннее, чем старт-бит + слово + четность + стоп-бит)

бит 3: ошибка синхронизации (получен нулевой стоп-бит)

бит 2: ошибка четности

бит 1: ошибка переполнения (пришел новый байт, хотя старый не был прочитан из 03F8h, при этом старый байт теряется)

бит 0: данные получены и готовы для чтения из 03F8h

03FDh для чтения — регистр состояния модема (MSR)

бит 7: линия DCD (несущая)

бит 6: линия RI (звонок)

бит 5: линия DSR (данные готовы)

бит 4: линия CTS (разрешение на посылку)

бит 3: изменилось состояние DCD

бит 2: изменилось состояние RI

бит 1: изменилось состояние DSR

бит 0: изменилось состояние CTS

02FFh для чтения и записи — запасной регистр. Не используется контроллером последовательного порта, любая программа может им пользоваться.

Итак, первое, что должна сделать программа, работающая с последовательным портом, — проинициализировать его, выполнив запись в регистр управления линией (03FBh) числа 80h, запись в порты 03F8h и 03F9h делителя частоты, снова запись в порт 03FBh с нужными битами, а также запись в регистр разрешения прерываний (03F9h) для выбора прерываний. Если программа вообще не пользуется прерываниями — надо записать в этот порт 0.

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

 
  
 ; term2.asm
 ; Минимальная терминальная программа, использующая прерывания
 ; Выход - Alt-X
 
         .model     tiny
         .code
         .186
         org        100h                 ; СОМ-программа
 
 ; следующие четыре директивы определяют, для какого 
 ; последовательного порта
 ; скомпилирована программа (никаких проверок не выполняется - 
 ; не запускайте этот
 ; пример, если у вас нет модема на соответствующем порту). 
 ; Реальная программа
 ; должна определять номер порта из конфигурационного файла 
 ; или из командной  строки
 COM                equ    02F8h         ; номер базового порта (COM2)
 IRQ                equ    0Bh           ; номер прерывания (INT 0Bh для IRQ3)
 E_BITMASK          equ    11110111b     ; битовая маска для разрешения IRQ3
 D_BITMASK          equ    00001000b     ; битовая маска для запрещения IRQ3
 
 start:
         call       init_everything      ; инициализация линии и модема
 main_loop:                              ; основной цикл
 ; реальная терминальная программа в этом цикле будет выводить 
 ; данные из буфера
 ; приема (заполняемого из обработчика прерывания) на экран, 
 ; если идет обычная
 ; работа, в файл, если пересылается файл, или обрабатывать 
 ; как-то по-другому.
 ; В нашем примере мы используем основной цикл для ввода символов, 
 ; хотя лучше это
 ; делать из обработчика прерывания от клавиатуры
         mov        ah,8                 ; Функция DOS 08h
         int        21h                  ; чтение с ожиданием и без эха,
         test       al,al                ; если введен обычный символ,
         jnz        send_char            ; послать его,
         int        21h       ; иначе - считать расширенный ASCII-код,
         cmp        al,2Dh               ; если это не Alt-X,
         jne        main_loop            ; продолжить цикл,
         call       shutdown_everything  ; иначе - восстановить все в
                                         ; исходное состояние
         ret                             ; и завершить программу
 
 send_char:                              ; посылка символа в модем
 ; Реальная терминальная программа должна здесь только добавлять 
 ; символ в буфер
 ; передачи и, если этот буфер был пуст, разрешать прерывания 
 ; "регистр передачи
 ; пуст". Просто пошлем символ напрямую в порт
         mov        dx,COM               ; регистр THR
         out        dx,al
         jmp        short main_loop
 
 old_irq dd         ? ; здесь будет храниться адрес старого обработчика
 
 ; упрощенный обработчик прерывания от последовательного порта
 irq_handler        proc    far
         pusha                           ; сохранить регистры
         mov        dx,COM+2             ; прочитать регистр идентификации
         in         al,dx                ; прерывания
 repeat_handler:
         and        ax,00000110b         ; обнулить все биты, кроме 1 и 2,
         mov        di,ax                ; отвечающие за 4 основные ситуации
         call       word ptr cs:handlers[di] ; косвенный вызов процедуры
                                             ; для обработки ситуации
         mov        dx,COM+2             ; еще раз прочитать регистр идентификации
         in         al,dx                ; прерывания,
         test       al,1                 ; если младший бит не 1,
         jz         repeat_handler       ; надо обработать еще одно прерывание,
         mov        al,20h               ; иначе - завершить аппаратное прерывание
         out        20h,al               ; посылкой команды EOI (см. главу 5.10.10)
         рора
         iret
 ; таблица адресов процедур, обслуживающих разные варианты прерывания
 handlers           dw    offset line_h, offset trans_h
                    dw    offset recv_h, offset modem_h
 
 ; эта процедура вызывается при изменении состояния линии
 line_h  proc       near
         mov        dx,COM+5             ; пока не будет прочитан LSR,
         in         al,dx     ; прерывание не считается завершившимся
 ; здесь можно проверить, что случилось, и, например, прервать связь, если
 ; обнаружено состояние BREAK
         ret
 line_h  endp
 ; эта процедура вызывается при приеме новых данных
 recv_h  proc       near
         mov        dx,COM               ; пока не будет прочитан RBR,
         in         al,dx       ; прерывание не считается завершившимся
 ; здесь следует поместить принятый байт в буфер приема 
 ; для основной программы,
 ; но мы просто сразу выведем его на экран
         int        29h                  ; вывод на экран
         ret
 recv_h  endp
 ; эта процедура вызывается по окончании передачи данных
 trans_h proc       near
 ; здесь следует записать в THR следующий символ из буфера передачи и, если
 ; буфер после этого оказывается пустым, запретить этот тип прерывания
         ret
 trans_h endp
 ; эта процедура вызывается при изменении состояния модема
 modem_h proc       near
         mov        dx,COM+6             ; пока MCR не будет прочитан,
         in         al,dx    ; прерывание не считается завершившимся
 ; здесь можно определить состояние звонка и поднять трубку, определить
 ; потерю несущей и перезвонить, и т.д.
         ret
 modem_h endp
 irq_handler        endp
 
 ; инициализация всего, что требуется инициализировать
 init_everything    proc    near
 ; установка нашего обработчика прерывания
         mov        ax,3500h+IRQ         ; АН = 35h, AL = номер прерывания
         int        21h      ; получить адрес старого обработчика
         mov        word ptr old_irq,bx  ; и сохранить в old_irq
         mov        word ptr old_irq+2,es
         mov        ax,2500h+IRQ         ; AH = 25h, AL = номер прерывания
         mov        dx,offset irq_handler ; DS:DX - наш обработчик
         int        21h                  ; установить новый обработчик
                                         ; сбросить все регистры порта
         mov        dx,COM+1             ; регистр IER
         mov        al,0
         out        dx,al                ; запретить все прерывания
         mov        dx,COM+4             ; MCR
         out        dx,al                ; сбросить все линии модема в О
         mov        dx,COM+5             ; и выполнить чтение из LSR,
         in         al,dx
         mov        dx,COM+0             ; из RBR
         in         al,dx
         mov        dx,COM+6             ; и из MSR
         in         al,dx                ; на тот случай, если они недавно
                                         ; изменялись,
         mov        dx,COM+2             ; а также послать 0 в регистр FCR,
         mov        al,0                 ; чтобы выключить FIFO
         out        dx,al
 
 ; установка скорости СОМ-порта
         mov        dx,COM+3             ; записать в регистр LCR
         mov        al,80h               ; любое число со старшим битом 1
         out        dx,al
         mov        dx,COM+0             ; теперь записать в регистр DLL
         mov        al,2                 ; младший байт делителя скорости,
         out        dx,al
         mov        dx,COM+1             ; а в DLH -
         mov        al,0                 ; старший байт
         out        dx,al                ; (мы записали 0002h -
                                         ; скорость порта 57 600)
 ; инициализация линии
         mov        dx,COM+3             ; записать теперь в LCR
         mov        al,0011b             ; число, соответствующее режиму 8N1
         out        dx,al                ; (наиболее часто используемому)
 ; инициализация модема
         mov        dx,COM+4             ; записать в регистр MCR
         mov        al,1011b             ; битовую маску, активирующую DTR, RTS
         out        dx,al                ; и OUT2
 ; здесь следует выполнить проверку на наличие модема на этом порту (читать
 ; регистр MSR, пока не будут установлены линии CTS и DSR или не кончится время),
 ; а затем послать в модем (то есть поместить в буфер передачи) 
 ; инициализирующую  строку, например "ATZ",0Dh
 
 ; разрешение прерываний
         mov        dx,COM+1             ; записать в IER - битовую маску,
         mov        al,1101b             ; разрешающую все прерывания, кроме
                                         ; "регистр передачи пуст"
         out        dx,al
         in         al,21h               ; прочитать OCW1 (см. главу 5.10.10)
         and        al,E_BITMASK         ; размаскировать прерывание
         out        21h,al               ; записать OCW1
         ret
 init_everything    endp
 
 ; возвращение всего в исходное состояние
 shutdown_everything   proc   near
 ; запрещение прерываний
         in         al,21h               ; прочитать OCW1
         or         al,D_BITMASK         ; замаскировать прерывание
         out        21h,al               ; записать OCW1
         mov        dx,COM+1             ; записать в регистр IER
         mov        al,0                 ; ноль
         out        dx,al                ; сброс линий модема DTR и CTS
         mov        dx,COM+4             ; записать в регистр MCR
         mov        al,0                 ; ноль
         out        dx,al                ; восстановление предыдущего
                                         ; обработчика прерывания
         mov        ax,2500h+IRQ         ; АН = 25h,  AL = номер прерывания
         lds        dx,old_irq           ; DS:DX - адрес обработчика
         int        21h
         ret
 shutdown_everything   endp
         end         start
 
 

Таймер

Все, что нам было известно до сих пор о системном таймере, — это устройство, вызывающее прерывание IRQ0 приблизительно 18,2 раза в секунду. На самом деле программируемый интервальный таймер — весьма сложная система, включающая в себя целых три устройства — три канала таймера, каждый из которых можно запрограммировать для работы в одном из шести режимов. И более того, на большинстве современных материнских плат располагаются два таких таймера, так что число каналов оказывается равным шести. Для своих нужд программы могут использовать канал 2 (если им не нужен динамик) и канал 4 (если присутствует второй таймер). При необходимости можно перепрограммировать и канал 0, но затем надо будет вернуть его в исходное состояние, чтобы BIOS и DOS могли продолжать работу.

В пространстве портов ввода-вывода для таймера выделена область от 40h до 5Fh:

порт 40h — канал 0 (генерирует IRQ0)

порт 41h — канал 1 (поддерживает обновление памяти)

порт 42h — канал 2 (управляет динамиком)

порт 43h — управляющий регистр первого таймера

порты 44h – 47h — второй таймер компьютеров с шиной MicroChannel

порты 48h – 4Bh — второй таймер компьютеров с шиной EISA

Все управление таймером осуществляется путем вывода одного байта в порт 43h (для первого таймера). Рассмотрим назначение бит в этом байте.

биты 7 – 6: если не 11 — это номер канала, который будет программироваться

00,01,10 = канал 0,1,2

биты 5 – 4:

00 — зафиксировать текущее значение счетчика для чтения (в этом случае биты 3 – 0 не используются)

01 — чтение/запись только младшего байта

10 — чтение/запись только старшего байта

11 — чтение/запись сначала младшего, а потом старшего байта

биты 3 – 1: режим работы канала

000: прерывание IRQ0 при достижении нуля

001: ждущий мультивибратор

010: генератор импульсов

011: генератор прямоугольных импульсов (основной режим)

100: программно запускаемый одновибратор

101: аппаратно запускаемый одновибратор

бит 0: формат счетчика:

0 — двоичное 16-битное число (0000 – FFFFh)

1 — двоично-десятичное число (0000 – 9999)

Если биты 7 – 6 равны 11, считается, что байт, посылаемый в порт 43h, — команда чтения счетчиков, формат которой отличается от команды программирования канала:

биты 7 – 6: 11 (код команды чтения счетчиков)

биты 5 – 4: режим чтения:

00: сначала состояние канала/потом значение счетчика

01: значение счетчика

10: состояние канала

биты 3 – 1: команда относится к каналам 3 – 1

Если этой командой запрашивается состояние каналов, новые команды будут игнорироваться, пока не прочтется состояние из всех каналов, которые были заказаны битами 3 – 1.

Состояние и значение счетчика данного канала получают чтением из порта, соответствующего требуемому каналу. Формат байта состояния имеет следующий вид:

бит 7: состояние входа OUTx на момент выполнения команды чтения счетчиков. Так как в режиме 3 счетчик уменьшается на 2 за каждый цикл, состояние этого бита, замороженное командой фиксации текущего значения счетчика, укажет, в каком полуцикле находился таймер

бит 6: 1/0 — состояние счетчика не загружено/загружено (используется в режимах 1 и 5, а также после команды фиксации текущего значения)

биты 5 – 0: совпадают с битами 5 – 0 последней команды, посланной в порт 43h

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

Вывести в регистр 43h команду (для канала 0) 0011011h, то есть установить режим 3 для канала 0, и при чтении/записи будет пересылаться сначала младшее слово, а потом старшее.

Послать младший байт начального значения счетчика в порт, соответствующий выбранному каналу (42h для канала 2).

Послать старший байт начального значения счетчика в этот же порт.

После этого таймер немедленно начнет уменьшать введенное число от начального значения к нулю со скоростью 1 193 180 раз в секунду (четверть скорости процессора 8088). Каждый раз, когда это число достигает нуля, оно снова возвращается к начальному значению. Кроме того, при достижении счетчиком нуля таймер выполняет соответствующую функцию — канал 0 вызывает прерывание IRQO, а канал 2, если включен динамик, посылает ему начало следующей прямоугольной волны, заставляя его работать на установленной частоте. Начальное значение счетчика для канала 0 по умолчанию составляет 0FFFFh (65 535), то есть максимально возможное. Поэтому точная частота вызова прерывания IRQ0 равна 1 193 180/65 536 = 18,20648 раза в секунду.

Чтобы прочитать текущее значение счетчика, надо:

Послать в порт 43h команду фиксации значения счетчика для выбранного канала (биты 5 – 4 равны 00h).

Послать в порт 43h команду перепрограммирования канала без изменения режима его работы, если нужно изменить способ чтения/записи (обычно не требуется).

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

Прочитать из того же порта старший байт.

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

Посмотрим в качестве примера, как при помощи таймера измерить, сколько времени проходит между реальным аппаратным прерыванием и моментом, когда обработчик этого прерывания получает управление (почему это важно, см. пример программ вывода звука из глав 5.10.8 и 5.10.9). Так как IRQ0 происходит при нулевом значении счетчика, нам достаточно прочитать его значение при старте обработчика и обратить его знак (потому что счетчик таймера постоянно уменьшается).

  
 ; latency.asm
 ; измеряет среднее время, проходящее между аппаратным прерыванием и запуском
 ; соответствующего обработчика. Выводит среднее время в микросекундах после
 ; нажатия любой клавиши (на самом деле в 1/1 193 180).
 ; Программа использует 16-битный сумматор для простоты, так что может давать
 ; неверные результаты, если подождать больше нескольких минут
 
         .model     tiny
         .code
         .386                            ; для команды shld
         org        100h                 ; COM-программа
 start:
         mov        ax,3508h             ; AH = 35h, AL = номер прерывания
         int        21h                  ; получить адрес обработчика
         mov        word ptr old_int08h,bx    ; и записать его в old_int08h
         mov        word ptr old_int08h+2,es
         mov        ax,2508h             ; AH = 25h, AL = номер прерывания
         mov        dx,offset int08h_handler  ; DS:DX - адрес обработчика
         int        21h                       ; установить обработчик
 ; с этого момента в переменной latency накапливается сумма
         mov        ah,0
         int        16h                  ; пауза до нажатия любой клавиши
         mov        ax,word ptr latency  ; сумма в АХ
         cmp        word ptr counter,0   ; если клавишу нажали немедленно,
         jz         dont_divide          ; избежать деления на ноль
         xor        dx,dx                ; DX = 0
         div        word ptr counter     ; разделить сумму на число накоплений
 dont_divide:
         call       print_ax             ; и вывести на экран
 
         mov        ax,2508h             ; АН = 25h, AL = номер прерывания
         lds        dx,dword ptr old_int08h   ; DS:DX = адрес обработчика
         int        21h                  ; восстановить старый обработчик
         ret                             ; конец программы
 
 latency            dw    0              ; сумма задержек
 counter            dw    0              ; число вызовов прерывания
 
 ; Обработчик прерывания 08h (IRQ0)
 ; определяет время, прошедшее с момента срабатывания IRQ0
 int08h_handler     proc    far
         push       ax                   ; сохранить используемый регистр
         mov        al,0                 ; фиксация значения счетчика в канале 0
         out        43h,al               ; порт 43h: управляющий регистр таймера
 ; так как этот канал инициализируется BIOS для 16-битного чтения/записи, другие
 ; команды не требуются
         in         al,40h               ; младший байт счетчика
         mov        ah,al                ; в АН
         in         al,40h               ; старший байт счетчика в AL
         xchg       ah,al                ; поменять их местами
         neg        ax                   ; обратить его знак, так как счетчик
                                         ; уменьшается
         add        word ptr cs:latency,ax   ; добавить к сумме
         inc        word ptr cs:counter      ; увеличить счетчик накоплений
         pop        ax
         db         0EAh                 ; команда jmp far
 old_int08h         dd    0              ; адрес старого обработчика
 int08h_handler     endp
 
 ; процедура print_ax
 ; выводит АХ на экран в шестнадцатеричном формате
 print_ax           proc    near
         xchg       dx,ax                ; DX = AX
         mov        cx,4                 ; число цифр для вывода
 shift_ax:
         shld       ax,dx,4              ; получить в AL очередную цифру
         rol        dx,4                 ; удалить ее из DX
         and        al,0Fh               ; оставить в AL только эту цифру
         cmp        al,0Ah               ; три команды, переводящие
         sbb        al,69h               ; шестнадцатеричную цифру в AL
         das                             ; в соответствующий ASCII-код
         int        29h                  ; вывод на экран
         loop       shift_ax             ; повторить для всех цифр
         ret
 print_ax           endp
         end        start
 
Таймер можно использовать для управления динамиком, для точных измерений отрезков времени, для создания задержек, для управления переключением процессов и даже для выбора случайного числа с целью запуска генератора случайных чисел — текущее значение счетчика канала 0 представляет собой идеальный вариант такого начального числа для большинства приложений.

Адресация в защищенном режиме

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

биты 15 – 3: номер дескриптора в таблице

бит 2: индикатор таблицы 0/1 — использовать GDT/LDT

биты 1 – 0: уровень привилегий запроса (RPL)

Уровень привилегий запроса — это число от 0 до 3, указывающее уровень защиты сегмента, для доступа к которому используется данный селектор. Если программа имеет более высокий уровень привилегий, при использовании этого сегмента привилегии понизятся до RPL. Уровни привилегий и весь механизм защиты в защищенном режиме нам пока не потребуется.

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

слово 3 (старшее):

биты 15 – 8: биты 31 – 24 базы

бит 7: бит гранулярности (0 — лимит в байтах, 1 — лимит в 4-килобайтных единицах)

бит 6: бит разрядности (0/1 — 16-битный/32-битный сегмент)

бит 5: 0

бит 4: зарезервировано для операционной системы

биты 3 – 0: биты 19 – 16 лимита

слово 2:

бит 15: бит присутствия сегмента

биты 14 – 13: уровень привилегий дескриптора (DPL)

бит 12: тип дескриптора (0 — системный, 1 — обычный)

биты 11 – 8: тип сегмента

биты 7 – 0: биты 23 – 16 базы

слово 1: биты 15 – 0 базы

слово 0 (младшее): биты 15 – 0 лимита

Два основных поля в этой структуре, которые нам интересны, — это база и лимит сегмента. База представляет линейный 32-битный адрес начала сегмента, а лимит — это 20-битное число, которое равно размеру сегмента в байтах (от 1 байта до 1 мегабайта), если бит гранулярности сброшен в ноль, или в единицах по 4096 байт (от 4 Кб до 4 Гб), если он установлен в 1. Числа отсчитываются от нуля, так что лимит 0 соответствует сегменту длиной 1 байт, точно так же, как база 0 соответствует первому байту памяти.

Остальные элементы дескриптора выполняют следующие функции:

Бит разрядности: для сегмента кода этот бит указывает на разрядность операндов и адресов по умолчанию. То есть в сегменте с этим битом, установленным в 1, все команды будут интерпретироваться как 32-битные, а префиксы изменения разрядности адреса или операнда будут превращать их в 16-битные, и наоборот. Для сегментов данных этот бит управляет тем, какой регистр (SP или ESP) используют команды, работающие с этим сегментом данных как со стеком.

Поле DPL определяет уровень привилегий сегмента.

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

Бит типа дескриптора — если он равен 1, сегмент является обычным сегментом кода или данных. Если этот бит — 0, дескриптор является одним из 16 возможных видов, определяемых полем типа сегмента.

Тип сегмента: для системных регистров в этом поле находится число от 0 до 15, определяющее тип сегментов (LDT, TSS, различные шлюзы), которые рассмотрены в главе 9. Для обычных сегментов кода и данных эти четыре бита выполняют следующие функции:

бит 11: 0 — сегмент данных, 1 — сегмент кода

бит 10: для данных — бит направления роста сегмента для кода — бит подчинения

бит 9: для данных — бит разрешения записи для кода — бит разрешения чтения

бит 8: бит обращения

Бит обращения устанавливается в 1 при загрузке селектора этого сегмента в регистр.

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

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

Бит направления роста сегмента обращает смысл лимита сегмента. В сегментах с этим битом, сброшенным в ноль, допустимы все смещения от 0 до лимита, а если этот бит — 1, то допустимы все смещения, кроме смещений от 0 до лимита. Про такой сегмент говорят, что он растет сверху вниз, так как если лимит, например, равен –100, допустимы смещения от –100 до 0, а если лимит увеличить, станут допустимыми еще меньшие смещения.

Для обычных задач программирования нам не потребуется все многообразие возможностей адресации. Все, что нам нужно, — это удобный неограниченный доступ к памяти. Поэтому мы будем рассматривать простую модель памяти — так называемую модель flat, в которой базы всех регистров установлены в ноль, а лимиты — в 4 Гб. Именно в такой ситуации окажется, что можно забыть о сегментации и пользоваться только 32-битными смещениями.

Для создания flat-памяти нам потребуются два дескриптора с нулевой базой и максимальным лимитом — один для кода и один для данных.

Дескриптор кода:

лимит FFFFFh

база 000000000h

тип сегмента FAh

бит присутствия = 1

уровень привилегий = 3 (минимальный)

бит типа дескриптора = 1

тип сегмента: 1010b (сегмент кода, для выполнения/чтения)

бит гранулярности = 1

бит разрядности = 1

db 0FFh, 0FFh, 0h, 0h, 0h, 0FAh, 0CFh, 0h

Дескриптор данных:

лимит FFFFFh

база 00000000h

бит присутствия = 1

уровень привилегий = 3 (минимальный)

бит типа дескриптора = 1

тип сегмента: 0010b (сегмент данных, растет вверх, для чтения/записи)

бит гранулярности = 1

бит разрядности = 1

db 0FFh, 0FFh, 0h, 0h, 0h, 0F2h, 0CFh, 0h

Для того чтобы процессор знал, где искать дескрипторы, операционная система собирает их в таблицы, которые называются GDT (таблица глобальных дескрипторов — может быть только одна) и LDT (таблица локальных дескрипторов — по одной на каждую задачу), и загружает их при помощи привилегированных команд процессора. Так как мы пока не собираемся создавать операционные системы, нам потребуется только подготовить дескриптор и вызвать соответствующую функцию VCPI или DPMI.

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

Ваше имя:
Комментарий:
Оба поля являются обязательными

 Автор  Комментарий к данной статье
Ольга
  Отличная статья...спасибо...много полезного нашла)))
2008-06-05 19:13:21
Doom666
  Да....Хорошая статья..
2010-10-14 02:59:48