Asm 2006

23

чие, рассмотрим пример задачи, связанной с обработкой матрицы, и решим её на Паскале и на Ассемблере.

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

Const N=20; M=30;

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

Begin

{ Ввод матрицы 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];

Для переноса программы с языка высокого уровня (в нашем случае с Паскаля) на язык низкого уровня (Ассемблер) необходимо выполнить два преобразования, которые в программистской литературе часто называются отображениями. Как говорят, надо отобразить с языка высокого уровня на язык низкого уровня структуру данных и структуру управления программы. В нашем примере главная структура данных в программе на Паскале – это прямоугольная таблица (матрица) целых чисел. При отображении матрица на линейную память некоторого сегмента данных в Ассемблере приходится, как говорят, линеаризировать матрицу. Этим мудрёным термином обозначают совсем простой процесс: сначала в сегменте данных размещается первая строка матрицы, сразу вслед на ней – вторая, и т.д. Для нашего примера в некотором сегменте надо каким-то образом зарезервировать 2*N*M байт памяти.1

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

Адрес(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]; {Так в Паскале нельзя}2

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

2В языке Турбо-Паскаль вместо недопустимого bx:=↑X[1,1]; можно использовать оператор присваи-

вания bx:=@X[1,1]

24

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 {Так в Паскале нельзя}

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

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

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

Команда

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;

25

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

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

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

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

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

В нашей архитектуре стек хранится в сегменте в перевёрнутом виде: начало сегмента является концом стека, а конец сегмента – началом стека. Кроме начала и конца, у стека есть текущая позиция

– вершина стека, её смещение от начала сегмента стека всегда записано в регистре SP (stack pointer). Следовательно, как мы уже знаем, физический адрес вершины стека можно получить по формуле

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

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

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

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

Влюбой момент времени регистр SP указывает на вершину стека – это последнее слово, записанное в стек. Таким образом, регистр SP является специализированным регистром, на что указывает и его название (SP - Stack Pointer), следовательно, хотя на нём и можно выполнять арифметические операции сложения и вычитания, но делать это следует только тогда, когда мы хотим изменить положение вершины стека. Обычно стек изображают, как показано на рис. 7.3.

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

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

Конец стека →

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

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

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

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

26

На этом рисунке, как и положено в нашей архитектуре, стек растёт снизу-вверх, занятая часть стека закрашена. В начале работы программы, когда стек пустой, регистр 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 слова или 128 байта, поэтому в начале работы регистр SP будет иметь значение 128, т.е., как мы и говорили ранее, он указывает на первое слово за концом стека. Области памяти в стеке обычно не имеют имён, так как доступ к ним, как правило, производится только с использованием регистров.

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

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

push op1

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

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

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

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

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

31

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

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

L: mov ax,1

. . .

call L

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

Изучение программирования процедур на Ассемблере начнём со следующей простой задачи, в которой "напрашивается" использование процедур. Пусть надо ввести массивы X и У знаковых целых чисел размером в слово, массив X содержит 100 чисел, а массив Y содержит 200 чисел. Затем необходимо вычислить величину Sum:

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

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

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

include io.asm data segment

Xdw 100 dup(?)

Ydw 200 dup(?) Sum dw ?

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

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