Баула В.Г. - Введение в архитектуру ЭВМ

52

Заметим теперь, что оба массива не поместятся в один сегмент данных (в сегменте не более примерно 32000 слов, а у нас в сумме 40000 слов), поэтому массив X мы размещаем в сегменте data1, а массив Y – в сегменте data2. Директива assume говорит, что на начала этих сегментов будут соответственно указывать регистры ds и es, что мы и обеспечили в самом начале программы. При вводе массивов мы использовали индексный регистр bx, в котором находится смещение текущего элемента массива от начала этого массива.

При вводе массива Y мы для учебных целей вместо предложения

L2: inint Y[bx];ввод очередного элемента

записали два предложения

L2: inint ax

mov Y[bx],ax;ввод очередного элемента

Это мы сделали, чтобы подчеркнуть: при доступе к элементам массива Y Ассемблер учитывает то, что имя Y описано в сегменте data2 и автоматически (используя информацию из директивы assume) поставит перед командой mov Y[bx],ax специальную однобайтную команду es: . Эту команду называют префиксом программного сегмента, так что на языке машины у нас будут две последовательные, тесно связанные команды:

es: mov Y[bx],ax

В цикле суммирования произведений для доступа к элементам массивов мы использовали другой приём, чем при вводе – регистры-указатели bx и si, в этих регистрах находятся адреса очередных элементов массивов. Напомним, что адрес – это смещение элемента относительно начала сегмента (в отличие от индекса элемента – это смещение от начала массива).

При записи команды умножение

mul word ptr es:[si]; умножение на Y[N-i+1]

мы вынуждены явно задать размер второго сомножителя и записать префикс программного сегмента es:, так как по виду операнда [si] Ассемблер не может сам "догадаться", что это элемент массива

Y размером в слово и из сегмента data2.

В команде

add bx,type X; это bx:=bx+2

для задания размера элемента массива мы использовали оператор type. Параметром этого оператора является имя из нашей программы, значением оператора type <имя> является целое число – тип данного имени. Для имён областей памяти это длина этой области в байтах (для массива это почти всегда длина одного элемента), для меток команд это отрицательное число –1, если метка расположена в том же сегменте, что и оператор type, или отрицательное число –2 для меток из других сегментов. Все остальные имена имеют тип ноль.

Вы, наверное, уже почувствовали, что программирование на Ассемблере сильно отличается от программирования на языке высокого уровня (например, на Паскале). Чтобы подчеркнуть это различие, рассмотрим пример задачи, связанной с обработкой матрицы, и решим её на Паскале и на Ассемблере.

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

Const N=20; M=30;

Var X: array[1..N,1..M] of integer; Sum,i,j: integer;

. . .

{ Ввод матрицы X } Sum:=0;

for i:=1 to N do

if X[i,1]<0 then

for j:=1 to M do Sum:=Sum+X[i,j];

Сначала обратим внимание на то, что переменные i и j несут в программе на Паскале двойную нагрузку: это одновременно и счётчики циклов, и индексы элементов массива. Такое совмещение функций упрощает понимание программы и делает её очень компактной по внешнему виду, но не проходит даром: чтобы по индексам элемента массива вычислить его адрес в сегменте, приходится выполнить достаточно сложные действия. Например, адрес элемента X[i,j] приходится вычислять так:

53

Адрес(X[i,j])= Адрес(X[1,1])+2*M*(i-1)+2*(j-1)

Эту формулу легко понять, учитывая, что матрица хранится в памяти по строкам (сначала первая строка, затем вторая и т.д.), и каждая строка имеет длину 2*M байт. Буквальное вычисление адресом элементов по приведённой выше формуле (а именно так чаще всего и делает Паскаль-машина) приводит к весьма неэффективной программе. При программировании на Ассемблере лучше всего разделить функции счётчика цикла и индекса элементов. В качестве счётчика лучше всего использовать регистр cx (он и специализирован для этой цели), а адреса лучше хранить в индексных регистрах (bx, si и di). Исходя из этих соображений, можно так переписать программу на Паскале, предвидя её будущий перенос на Ассемблер.

Const N=20; M=30;

Var X: array[1..N,1..M] of integer; Sum,cx,oldcx: integer; bx: ↑integer;

. . .

{ Ввод матрицы X }

Sum:=0; bx:=↑X[1,1]; {Так в Паскале нельзя} for cx:=N downto 1 do

if bx↑<0 then begin oldcx:=cx; for cx:=M downto 1 do begin

Sum:=Sum+bx↑; bx:=bx+2 {Так в Паскале нельзя} end;

cx:=oldcx end

else bx:=bx+2*M {Так в Паскале нельзя}

Теперь осталось переписать этот фрагмент программы на Ассемблере:

;Ввод матрицы X mov Sum,0

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

54

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

Вернёмся к описанию команд цикла. В языке Ассемблера есть и другие команды цикла, которые могут производить досрочный (до исчерпания счётчика цикла) выход из цикла. Как и для команд условного перехода, для мнемонических имен некоторых из них существуют синонимы, которые мы будем разделять в описании этих команд символом /.

Команда

loopz/loope L

выполняется по схеме

Dec(CX); if (CX<>0) and (ZF=1) then goto L;

А команда loopnz/loopne L

выполняется по схеме

Dec(CX); if (CX<>0) and (ZF=0) then goto L;

Вэтих командах необходимо учитывать, что операция Dec(CX) является частью команды цикла

ине меняет флага ZF.

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

7.7. Работа со стеком

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

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

Кроме начала, у стека есть текущая позиция – вершина стека, её смещение от начала сегмента стека записано в регистре SP (stack pointer). Следовательно, как мы уже знаем, физический адрес вершины стека можно получить по формуле Афиз = (SS*16 + SP)mod 220.

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

Всоответствие с определением понятия стек последнее записанное в него слово будет читаться

из стека первым. Это так называемое правило "последний пришёл – первый вышел" (английское сокращение LIFO).1 Обычно стек принято изображать "растущим" снизу-вверх. Как следствие получается, что конец стека фиксирован и расположен снизу, а вершина двигается вверх (при записи

встек) и вниз (при чтении из стека).

Вкаждый момент времени регистр SP указывает на последнее слово, записанное в стек. Обычно стек изображают, как показано на рис. 7.1.

Начало стека SS →

Вершина стека SP →

Конец стека →

SP для пустого стека →

1 Вообще говоря, это же правило можно записать и как "первый пришёл – последний вышел" (английское сокращение FILO). В литературе встречаются оба этих правила и их сокращения.

55

Рис. 7.1. Так мы будем изображать стек.

На нашем рисунке, как обычно, стек растёт снизу-вверх, занятая часть стека закрашена. В начале работы программы, когда стек пустой, регистр SP указывает на первое слово за концом стека. Особым является случай, когда стек имеет максимальный размер 216 байт, в этом случае значение регистра SP для пустого стека равно нулю, т.е. совпадает со значением этого регистра и для полного стека, поэтому стеки максимального размера использовать не рекомендуется, так как будет затруднён контроль пустоты и переполнения стека.

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

stack segment stack dw 64 dup (?)

stack ends

Имя сегмента стека и способ резервирования памяти может быть любым, например, можно описать такой стек:

st_1 segment stack

db 128 dup (?) st_1 ends

То, что этот сегмент будет при выполнении программы использоваться именно как сегмент стека, указывается параметром stack директивы segment. Этот параметр является служебным словом языка Ассемблера и, вообще говоря, не должен употребляться ни в каком другом смысле. 1

В нашем последнем примере размер сегмента стека установлен в 64 слова, поэтому в начале работы регистр SP будет иметь значение 128, т.е., как мы и говорили ранее, указывает на первое слово за концом стека. Области памяти в стеке обычно не имеют имён, так как доступ к ним, как правило, производится только с использованием регистров.

Обратим здесь внимание на важное обстоятельство. Перед началом работы со стеком необходимо загрузить в регистры SS и SP требуемые значения, однако сама программа это сделать не может, т.к. при выполнении самой первой команды программы стек уже должен быть доступен (почему это так мы узнаем в нашем курсе позже, когда будем изучать механизм прерываний). Поэтому в рассмотренных выше примерах программ мы сами не загружали в регистры SS и SP никаких начальных значений. Как мы узнаем позже, перед началом выполнения нашей программы этим регистрам присвоит значения специальная системная программа загрузчик, которая размещает нашу программу в памяти и передаёт управление на команду, помеченную той меткой, которая указана в конце нашего модуля в качестве параметра директивы end. Разумеется, позже при работе программы мы и сами можем загрузить в регистр SS новое значение, это будет переключением на другой сегмент стека.

Рассмотрим сначала те команды работы со стеком, которые не являются командами перехода. Команда

push op1

где op1 может иметь форматы r16, m16, CS,DS,SS,ES, записывает в стек слово, определяемое своим операндом. Это команда выполняется по правилу:

SP := (SP – 2)mod 216 ; <SS,SP> := op1

Здесь запись <SS,SP> обозначает адрес в стеке, вычисляемый по формуле

Афиз = (SS*16 + SP)mod 220 .

Особым случаем является команда push SP

В младших моделях нашего семейства она выполняется, как описано выше, а в старших – по схеме

<SS,SP> := SP; SP := (SP – 2)mod 216

1 Иногда в наших примерах мы, следуя учебнику [5], называли так же и сам сегмент стека. Некоторые компиляторы с Ассемблера (например, MASM-4.0) допускают это, если по контексту могут определить, что это именно имя пользователя, а не служебное слово. Другие компиляторы (например, Турбо-Ассемблер) подходят к этому вопросу более строго и не допускают использование служебных слов в качестве имён пользователя. Все служебные слова Ассемблера мы выделяем жирным шрифтом.

56

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

Команда

pop op1

где op1 может иметь форматы r16, m16, SS, DS, ES, читает из стека слово и записывает его в место памяти, определяемое своим операндом. Это команда выполняется по правилу:

op1 := <SS,SP>; SP := (SP + 2)mod 216

Команда pushf

записывает в стек регистр флагов FLAGS, а команда popf

наоборот, читает из стека слово и записывает его в регистр флагов FLAGS. Эти команды удобны для сохранения в стеке и восстановления значения регистра флагов.

В старших моделях нашего семейства появились две новые удобные команды работы со стеком. Команда

pusha

последовательно записывает в стек регистры AX,CX,DX,BX,SP (этот регистр записывается до его изменения), BP,SI и DI. Команда

popa

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

Команды записи в стек не проверяют того, что стек уже полон, для надёжного программирования это должен делать сам программист. Например, для проверки того, что стек уже полон, и писать в него нельзя, можно использовать команду сравнения

cmp SP,0; стек уже полон ?

и выполнить условный переход, если регистр SP равен нулю. Особым случаем здесь будет стек максимального размера 216 байт, для него значение регистра SP=0 как для полного, так и для пустого стека (обязательно понять это!), поэтому не рекомендуется использовать стек максимального размера.

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

cmp SP,K; стек пуст ?

где K – чётное число – размер стека в байтах. Если размер стека в байтах нечётный, то стек полон при SP=1, т.е. в общем случае необходима проверка SP<2. Обычно избегают задавать стеки нечётной длины, для них труднее проверить и пустоту стека.

В качестве примера использования стека рассмотрим программу для решения следующей задачи. Необходимо вводить целые беззнаковые числа до тех пор, пока не будет введено число ноль (признак конца ввода). Затем следует вывести в обратном порядке то из введённых чисел, которые принадлежат диапазону [2..100] (сделаем спецификацию, что таких чисел может быть не более 300). Ниже приведено возможное решение этой задачи.

include io.asm

57

outstr newline

sub cx,cx; хороший способ для cx:=0

L:inint ax

cmp ax,0; проверка конца ввода je Pech; на вывод результата cmp ax,2

end program_start

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

Обратите внимание, как мы выбрали размер стека: 128 байт мы зарезервировали для системных нужд (как уже упоминалось, стеком будут пользоваться и другие программы, подробнее об этом будет рассказано далее) и 300 слов мы отвели для хранения введённых нами чисел. При реализации этой программы может возникнуть желание определять, что введено слишком много чисел, анализируя переполнение стека. Другими словами, вместо проверки

cmp cx,300; в стеке уже 300 чисел ? je Err

казалось бы, можно было поставить проверку исчерпания стека cmp SP,2; стек уже полон ?

jb Err

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

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

7.8. Команды вызова процедуры и возврата из процедуры

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

call op1

59

Будем предполагать, что массивы находятся в одном сегменте данных, а переполнение результата при сложении будем для простоты игнорировать (не выдавать диагностику). Для данной программы естественно реализовать процедуру суммирования элементов массива и дважды вызывать эту процедуру для массивов X и Y. Текст нашей процедуры мы, как и в Паскале, будем располагать перед текстом основной программы (начало программы, как мы знаем, помечено меткой, указанной в директиве end нашего модуля).

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

Перед тем, как писать процедуру, необходимо составить соглашение о связях между основной программой и процедурой.1 Это соглашение включает в себя способ передачи параметров, возврата результата работы и некоторую другую информацию. Так, мы "договоримся" с процедурой, что суммируемый массив слов будет располагаться в сегменте данных, адрес первого элемента перед вызовом процедуры будет записан в регистр bx, а количество элементов – в регистр cx. Сумма элементов массива при возврате из процедуры должна находится в регистре ax. При этих соглашениях о связях у нас получится следующая программа (для простоты вместо команд для ввода массивов вы указали только комментарий).

include io.asm data segment

Xdw 100 dup(?)

Ydw 200 dup(?)

;соглашение о связях: bx – адрес первого элемента

;cx=количество элементов, ax – ответ (сумма)

sub ax,ax; сумма:=0

L:add ax,[bx] add bx,2 loop L

outint Sum newline finish

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