7.6.3. Команды цикла
Для организации циклов на Ассемблере вполне можно использовать команды условного перехода. Например, цикл языка Паскаль с предусловием while X<0 do S; можно реализовать в виде следующего фрагмента на Ассемблере
L: cmp X,0; Сравнить X с нулём
jge L1
; Здесь будет оператор S
jmp L
L1: . . .
Оператор цикла с постусловием repeat S1; S2;. . .Sk until X<0; можно реализовать в виде фрагмента на Ассемблере
L: ; S1
; S2
. . .
; Sk
cmp X,0; Сравнить X с нулём
jge L
. . .
В этих примерах мы считаем, что тело цикла по длине не превышает примерно 120 байт (это 30-40 машинных команд). Как видим, цикл с постусловием требует для своей реализации на одну команду меньше, чем цикл с предусловием.
Как мы знаем, если число повторений выполнения тела цикла известно до начала исполнения этого цикла, то в языке Паскаль наиболее естественно было использовать цикл с параметром. Для организации цикла с параметром в Ассемблере можно использовать специальные команды цикла. Команды цикла, по сути, тоже являются командами условного перехода и, как следствие, реализуют только близкий короткий относительный переход. Команда цикла
loop L; Метка L заменится на операнд i8
использует неявный операнд – регистр CX и её выполнение может быть так описано с использованием Паскаля:
Dec(CX); {Это часть команды loop, поэтому флаги не меняются!}
if CX<>0 then goto L;
Как видим, регистр CX (который так и называется регистром счётчиком цикла – loop counter), используется этой командой именно как параметр цикла. Лучше всего эта команда цикла подходит для реализации цикла с параметром языка Паскаль вида
for CX:=N downto 1 do S;
Этот оператор можно эффективно реализовать таким фрагментом на Ассемблере:
mov CX,N
jcxz L1
L: . . .; Тело цикла –
. . .; оператор S
loop L
L1: . . .
Обратите внимание, так как цикл с параметром языка Паскаль по существу является циклом с предусловием, то до начала его выполнение проверяется исчерпание значений для параметра цикла с помощью команды условного перехода jcxz L1 , которая именно для этого и была введена в язык машины. Ещё раз напоминаем, что команды циклов не меняют флагов.
Описанная выше команда цикла выполняет тело цикла ровно N раз, где N – беззнаковое число, занесённое в регистр-счётчик цикла CX перед началом цикла. К сожалению, никакой другой регистр нельзя использовать для этой цели (т.к. это неявный параметр команды цикла). Кроме того, в приведённом выше примере реализации цикла тело этого не может быть слишком большим, иначе команда loop L не сможет передать управление на метку L.
В качестве примера использования команды цикла решим следующую задачу. Требуется ввести беззнаковое число N<=500, затем ввести N знаковых целых чисел и вывести сумму тех из них, которые принадлежат диапазону –2000..5000. Можно предложить следующее решение этой задачи.
include io.asm
; файл с макроопределениями для макрокоманд ввода-вывода
data segment
N dw ?
S dw 0; Начальное значение суммы = 0
T1 db ′Введите N<=500 $′
T2 db ′Ошибка – большое N!$′
T3 db ′Вводите целые числа′,10,13,′$′
T4 db ′Ошибка – большая сумма!$′
data ends
stack segment stack
dw 64 dup (?)
stack ends
code segment
assume cs:code,ds:data,ss:stack
start:mov ax,data
mov ds,ax
mov dx, offset T1; Приглашение к вводу
outstr
inint N
cmp N,500
jbe L1
mov dx, offset T2; Диагностика от ошибке
Err: outstr
newline
finish
L1: mov cx,N; Счётчик цикла
jcxz Pech; На печать результата
mov dx,offset T3; Приглашение к вводу
outstr
newline
L2: inint ax; Ввод очередного числа
cmp ax,-2000
jl L3
cmp ax,5000
jg L3; Проверка диапазона
add S,ax; Суммирование
jno L3; Проверка на переполнение S
mov dx,offset T4
jmp Err
L3: loop L2
Pech: outch ′S′
outch ′=′
outint S
newline
finish
code ends
end start
В качестве ещё одного примера рассмотрим использование циклов при обработке массивов. Пусть необходимо составить программу для решения следующей задачи. Задана константа N=20000, надо ввести массивы X и Y по N беззнаковых чисел в каждом массиве и вычислить выражение
Для простоты будем предполагать, что каждое из произведений и вся сумма имеют формат dw (помещаются в слово). Ниже приведена программа, решающая эту задачу.
include io.asm
N equ 20000; Аналог Const N=20000; Паскаля
data1 segment
T1 db ′Вводите числа массива $′
T2 db ′Сумма = $′
T3 db ′Ошибка – большое значение!′,10,13,′$′
S dw 0; искомая сумма
X dw N dup (?); 2*N байт
data1 ends
data2 segment
Y dw N dup (?); 2*N байт
data2 ends
st segment stack
dw 64 dup(?)
st ends
code segment
assume cs:code,ds:data1,es:date2,ss:st
begin_of_program:
mov ax,data1
mov ds,ax; ds – на начало data1
mov ax,data2
mov es,ax; es – на начало data2
mov dx, offset T1; Приглашение к вводу
outstr
outch ′X′
newline
mov cx,N; счётчик цикла
mov bx,0; индекс массива
L1: inint X[bx];ввод очередного элемента X[i]
add bx,2; увеличение индекса, это i:=i+1
loop L1
outstr; Приглашение к вводу
outch ′Y′
newline
mov cx,N; счётчик цикла
mov bx,0; индекс массива
L2: inint ax
mov Y[bx],ax; ввод очередного элемента es:Y[bx]
add bx,2; увеличение индекса
loop L2
mov bx,offset X; указатель на X[1]
mov si,offset Y+2*N-2; указатель на Y[N]
L3: mov ax,[bx]; первый сомножитель
mul word ptr es:[si]; умножение на Y[N-i+1]
jc Err; большое произведение
add S,ax
jc Err; большая сумма
add bx,type X; это bx:=bx+2
sub si,2; это i:=i-1
loop L3; цикл суммирования
mov dx, offset T2
outstr
outword S
newline
finish
Err: mov dx,T3
outstr
finish
code ends
end begin_of_program
Подробно прокомментируем эту программа. Количество элементов массивов мы задали, используя директиву эквивалентности N equ 20000 , это есть указание программе Ассемблера о том, что всюду в программе, где встретится имя N, надо подставить вместо него операнд этой директивы – число 20000. Таким образом, это почти полный аналог описания константы в языке Паскаль.1 Под каждый из массивов директива dw зарезервирует 2*N байт памяти.
Заметим теперь, что оба массива не поместятся в один сегмент данных (в сегменте не более примерно 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 ptres:[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] приходится вычислять так:
Адрес(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 {Так в Паскале нельзя}
Теперь осталось переписать этот фрагмент программы на Ассемблере:
N equ 20
M equ 30
oldcx equ di
Data segment
X dw N*M dup (?)
Sum dw ?
. . .
Data ends
. . .
; Ввод матрицы X
mov Sum,0
mov bx,offset X; Адрес X[1,1]
mov cx,N
L1: cmp word ptr [bx],0
jge L3
mov oldcx,cx
mov cx,M
L2: mov ax,[bx]
add Sum,ax
add bx,2
loop L2
mov cx,oldcx
jmp L4
L3: add bx,2*M
L4: loop L1
Приведённый пример очень хорошо иллюстрирует стиль мышления программиста на Ассемблере. Для доступа к элементам обрабатываемых данных применяются указатели (ссылочные переменные, адреса), и используются операции над этими адресами (адресная арифметика). Получающиеся программы могут максимально эффективно использовать все особенности архитектуры используемого компьютера. Применение адресом и адресной арифметики свойственно и некоторым языкам высокого уровня (например, языку С), который ориентирован на использование особенности машинной архитектуры для написания более эффективных программ.
Вернёмся к описанию команд цикла. В языке Ассемблера есть и другие команды цикла, которые могут производить досрочный (до исчерпания счётчика цикла) выход из цикла. Как и для команд условного перехода, для мнемонических имен некоторых из них существуют синонимы, которые мы будем разделять в описании этих команд символом /.
Команда
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. Такие команды используются в основном при работе с массивами, для усвоения этого материала Вам необходимо изучить соответствующий раздел учебника по Ассемблеру.