Файл: 2005 Рудольф Марек. Ассемблер на примерах. Базовый курс. .pdf

Глава 7 Полезные фрагменты кода Простые примеры Преобразование числа в строку Преобразование строки в число Ассемблер на примерах. Базовый курс

В этой главе мы представим несколько подпрограмм, которые можно использовать в большинстве ваших ассемблерных программ. Мы будем рассматривать только системно-независимый код, одинаково пригодный для любой операционной системы. Программы, использующие особенности операционных систем, будут рассмотрены в следующих главах.
7.1. Простые примеры Начнем с нескольких простых примеров, которые помогут уменьшить пропасть между языком высокого уровня и ассемблером. Сложение двух переменных Задача сложить два разрядных числа, содержащихся в переменных num- b e r l и number2, а результат сохранить в переменной r e s u l t . Сначала нужно выбрать регистры, куда будут загружены нужные значения. Затем нужно сложить эти регистры, а результат записать в переменную r e ­
s u l t : mov eax,[number1] mov ebx,[number2] add eax,ebx mov [result],eax квадратные скобки означают доступ к памяти
;ЕВХ = number2
;ЕАХ = ЕАХ + ЕВХ сохраняем результат в переменной r e s u l t number1 dd 8 number2 dd 2 определяем переменную numberl и инициализируем 8 переменную number2 инициализируем значением 2 определяем переменную result r e s u l t dd 0 Мы можем переписать программу, используя на подхвате регистр ЕАХ: mov eax,[numberl] ;EAX = "numberl" add eax,[number2] ;EAX = EAX + number2 mov [result],eax сохраняем результат в переменной result
98

Глава 7. Полезные фрагменты кода Сложение двух элементов массива Задача сложить два 32-битных числа. Регистр EDI содержит указатель на первое слагаемое, второе слагаемое расположено непосредственно за первым. Результат записать в EDX. Фактически мы имеем массив из двух 32-битных чисел, адрес которого задан указателем в регистре EDI. Каждый элемент массива занимает 4 байта, следовательно, второй элемент расположен по адресу, на 4 байта большему. mov e d x , [ e d i ] add e d x , [ e d i + 4 ; загружаем в EDX первый элемент массива складываем его со вторым, результат — в EDX Дополним программу загрузкой регистра EDI: mov e d i , n u m b e r s загружаем в EDI адрес массива numbers
;какие-то команды mov e d x , [ e d i ] загружаем в EDX первый элемент массива add e d x , [ e d i + 4 ] прибавляем второй элемент numbers dd l dd 2 массив numbers инициализируется значениями 1 и 2, поэтому результат в EDX будет равен 3 у второго элемента массива нет особого имени В следующем пункте мы расскажем, как работать с массивами в цикле. Суммируем элементы массива Задача вычислить сумму массива разрядных чисел, если в ESI загружен адрес первого элемента массива. Массив заканчивается нулевым байтом. Сумма разрядных чисел может оказаться числом большей разрядности, поэтому на всякий случай отведем для хранения результата 32-битный регистр. Элементы массива будут суммироваться до тех пор, пока не будет встречен нулевой байт. mov esi,array mov ebx,0 mov eax,ebx again: mov al,[esi] inc esi add ebx,eax cmp a1,0 jnz again array db 1,2,3,4 загружаем в ESI начало массива
;ЕВХ = О
;ЕАХ = О загружаем в AL элемент массива перемещаем указатель на след. элемент
;ЕВХ = ЕВХ + ЕАХ
;AL равен нулю переходим к again, если AL не О
5,6,7,8,0 инициализируем массив. Сумма (ЕВХ) должна быть равна 3 6 99

Ассемблер на примерах. Базовый курс Рис. 7.1. Блок-схема алгоритма суммирования массива Чет и нечет Задача определить, четное или нечетное значение содержит регистр АХ. Четное число отличается от нечетного тем, что его младший бит равен нулю. Используя SHR, мы можем сдвинуть этот битва затем проверить этот бит, выполнив условный переход. p u s h ax сохраняем исходное значение АХ в стеке ах перемещаем младший бит АХ в CF pop ax восстанавливаем оригинальное значение jc odd если CF = 1, переходим к odd e v e n : ; действия, если число в в АХ - четное odd: ; действия, если число в в АХ — нечетное Как обычно, мы можем переписать этот фрагмент кода проще t e s t a l , l младший бит маски содержит 1, вызываем TEST jz even ;ZF (флаг нуля) установлен, если результат равен 0, о есть младший бит = 0, то есть число четное odd: e v e n : ; действия, если АХ — четное Обратите внимание, что мы тестировали только AL, а не весь регистр АХ. Старшие биты АХ для проверки четности совершенно ненужны Глава 7. Полезные фрагменты кода Перестановка битов в числе Задача реверсируем порядок битов числа, сохраненного в AL, то есть переставим младший бит на место старшего, второй справа — на место второго слева и т.д. Полученный результат сохраним в АН. Например, наше число равно 0x15, то есть 00010101b. После реверсирования мы получим его зеркальное отображение 10101000b, то есть 0хА8. Как обычно, поставленную задачу можно решить несколькими способами. Можно пройтись по всем битам AL так, как показано в параграфе о битовых массивах, проверяя значение отдельных битов и устанавливая в соответствии с ним значения отдельных битов АН, но это не лучшее решение. Оптимальным в нашем случае будет использование инструкций сдвига и ротации. Например, используя SHR (как в предыдущем примере, мы можем вытолкнуть один битв (флаг переноса) и, используя RCL, переместить этот битв младший бит операнда. Повторив это действие 8 раз, мы решим поставленную задачу. mov с х , 8 наш счетчик СХ = 8 t h e l o o p : s h r a l , l сдвигаем AL набит вправо, младший битв сдвигаем АН набит влево, заменяем младший бит на CF l o o p t h e l o o p повторяем 8 раз Проверка делимости числа нацело Задача определить, заканчивается ли десятичная запись числа цифрой нуль. Простого сравнения битов здесь недостаточно, мы должны разделить число на
10 (ОхА). Операция целочисленного деления помещает в регистр AL частное, а в регистр АН — остаток. Нам останется только сравнить остаток с нулем если число делится нацело, то передадим управление наметку. Для определенности считаем, что наше число находится в регистре АХ mov Ы,0хА ;BL = 10 - делитель d i v bl делим АХ на BL cmp a h , 0 остаток = 0? jz y e s если да, перейти к YES по если нет, продолжить yes :
101

Ассемблер на примерах. Базовый курс
7.2. Преобразование числа в строку Чтобы вывести число на экран, нужно преобразовать его в строку. В высоко­
уровневых языках программирования это действие давно стало тривиальным для преобразования числа в строку достаточно вызвать всего одну функцию. А вот на языке ассемблера эту подпрограмму еще нужно написать, чем мы и займемся в этом параграфе. Как бы мы решали эту задачу на С Делили бы в цикле на 10 и записывали остатки, преобразуя их в символы цифр добавлением кода цифры 0 (см. таблицу кодов ASCII, рис. 1.2). Цикл повторялся бы до тех пор, пока частное не стало бы нулем. Вот соответствующий код
#include void main(void) { unsigned int number; char remainder; number=12345 678; while (number 1= 0)
{ remainder = (number % 10)+'0';
/* remainder = number mod 10 + char('0') */ number /=10; /* number = number div 10*/ printf("%c",remainder);
}
} Рис. 7.2. Блок-схема алгоритма преобразования числа в строку
102

Глава 7. Полезные фрагменты кода Правда, программа выведет немного не то, что мы ожидали наше число равно
12345678, нона экране мы увидим 87654321, — это потому что при делении мы получаем сначала младшие цифры, а потом старшие. Как теперь перевернуть полученную последовательность символов При программировании на языке ассемблера нам доступен стек, куда можно сохранять наши остатки, а затем, вытолкнув их из стека, получить правильную последовательность. Мы оформим функцию преобразования числа в строку в виде подпрограммы, которую вы можете использовать в любой своей программе на языке ассемблера. Первая проблема, которую предстоит решить — передача параметров. Мы знаем, что в высокоуровневых языках программирования параметры передаются через стек. Однако мы будем использовать более быстрый способ передачи параметров — через регистры процессора. В регистр ЕАХ мы занесем число, а после выполнения подпрограммы регистр
EDI будет содержать адрес памяти (или указатель, по которому сохранен первый байт нашей строки. Сама строка будет заканчиваться нулевым байтом как в С. Наша подпрограмма convert состоит из двух циклов. Первый цикл соответствует циклу while из предыдущего листинга — внутри него мы будем помещать остатки в стек, попутно преобразуя их в символы цифр, пока частное не сравняется с нулем. Второй цикл извлекает цифры из стека и записывает в указанную строку. Наша подпрограмма convert может выглядеть так, как показано в листинге 7.1. Листинг 7.1. Программа преобразования числа в строку предварительный вариант)
convert: mov ecx,0 mov О
.dividei mov edx,0 div ebx add edx, ' 0' push edx inc ecx cmp eax,0 jnz .divide
.reverse: pop eax
;ЕСХ = О
;ЕВХ = 010
;EDX = 0 делим ЕАХ на ЕВХ, частное в ЕАХ, остаток в EDX добавляем код цифры 0 к остатку сохраняем в стеке увеличиваем счетчик цифр в стеке закончили (частное равно 0?) если нет, переходим к .divide иначе число уже преобразовано, цифры сохранены в стеке, ЕСХ содержит их количество выталкиваем цифру из стека
103

Ассемблер на примерах. Базовый курс mov [edi] add e d i , 1 dec ecx al cmp ecx,0 jnz . reverse ret помещаем ее в строку перемещаем указатель наследующий символ уменьшаем счетчик цифр, оставшихся в стеке цифры кончились Нет Обрабатываем следующую Да Возвращаемся Эту программу я намеренно написал с недостатками. Попробуем ее оптимизировать, руководствуясь предыдущей главой. Начнем с замены команды MOV ecx, 0 на более быструю — XOR ecx, ecx. Далее, вместо загрузки в ЕВХ 10 мы можем сбросить этот регистр (записать в него 0), а потом загрузить 10 в BL: так мы избавимся от использования длинного непосредственного операнда. Проверка ЕАХ на 0 может быть заменена инструкцией OR eax,eax (или
TEST eax,eax). А две команды записи байта в строку можно заменить одной вместо mov [ e d i ] , a l add e d i , 1 напишем stosb Эта команда делает тоже самое, но занимает всего один байт. Последний цикл нашей функции можно переписать с использованием команды
LOOP. В итоге функция будет выглядеть так, как показано в листинге 7.2. Листинг 7,2. Программа преобразования числа в строку промежуточный вариант)
convert: хог есх,есх xor ebx,ebx mov Ы , 1 0
.divide: xor edx,edx div ebx add dl,'0' push edx inc ecx or eax,eax jnz .divide
;ЕСХ = О
;ЕВХ
= О теперь ЕВХ = 010
;EDX = 0 делим ЕАХ на ЕВХ, частное в ЕАХ, остаток в EDX добавляем код цифры 0 к остатку сохраняем в стеке увеличиваем счетчик цифр в стеке закончили (частное равно 0?) если не 0, переходим к .divide. Иначе число уже преобразовано, цифры сохранены в стеке,
;ЕСХ содержит их количество
104

Глава 7. Полезные фрагменты кода
. r e v e r s e : pop eax ; выталкиваем цифру из стека s t o s b ; записываем AL по адресу, содержащемуся в
;EDI, увеличиваем EDI на 1 loop . r e v e r s e ;ЕСХ=ЕСХ-1, переходим, если ЕСХ неравно О r e t Да Возвращаемся Мы слегка улучшили программу, но она все еще работает неправильно. Необходимый нулевой байт не записывается вконец строки, поэтому нужно добавить дополнительную инструкцию
MOV b y t e [ e d i ] , 0 Ее нужно вставить между LOOP и RET. Обратите внимание на слово byte — оно очень важно, поскольку сообщает компилятору о том, какого размера нуль нужно записать по адресу EDI. Самостоятельно он определить этого не может. Строку завершает нулевой байт, поэтому нуль размером в байт мы и запишем. Наша программа уничтожает исходное содержимое некоторых регистров
(ЕАХ, ЕВХ, ЕСХ, EDX и EDI). Чтобы их сохранить, перед изменением этих регистров нужно поместить их значения в стека затем извлечь их оттуда в правильном порядке. Вызывать нашу подпрограмму нужно так mov eax,0x12345678 ; загрузить в ЕАХ число, подлежащее преобразованию mov e d i , b u f f ; загрузить в EDI адрес буфера для записи строки c a l l c o n v e r t вызов подпрограммы Число, которое мы хотим преобразовать, перед вызовом подпрограммы загружаем в регистр ЕАХ. Второй параметр — это указатель на адрес в памяти, куда будет записана наша строка. Указатель должен быть загружен вили (в зависимости от режима процессора. Команда CALL вызывает нашу подпрограмму. В результате ее выполнения созданная строка будет записана по указанному адресу. Наша функция convert преобразует число только в десятичное представление. Сейчас мы изменим ее так, чтобы получать число в шестнадцатеричной записи. Мы получаем десятичные цифры, прибавляя к остаткам код цифры нуль. Это возможно, потому что символы цифр в таблице расположены последовательно (рис. 1.2). Но если наши остатки получаются отделения на
16, тонам понадобятся цифры А — F, расположенные в таблице тоже последовательно, ноне вслед за цифрой 9. Решение простое если остаток
105

Ассемблер на примерах. Базовый курс больше 9, то мы будем прибавлять к нему другую константу. Вместо добавления к остатку кода нуля будем вызывать еще одну подпрограмму,
H e x D i g i t :
0-15,
H e x D i g i t : cmp d l , 1 0 j b . l e s s add d l , ' A ' r e t
. l e s s : o r d l , ' 0 ' r e t в DL ожидается число нужно сопоставить ему шестнадцатеричную цифру сравниваем DL с 10 переходим, если меньше
-10 ;10 превращается в ' А ' , 11 в ' В ' и т . д . конец подпрограммы можно прибавлять итак конец подпрограммы Модифицируя подпрограмму convert, не забудьте заменить делитель 10 на
0x10, то есть 16. А теперь обобщим нашу подпрограмму так, чтобы она преобразовывала число в строку в любой системе счисления. После того, как мы написали универсальную подпрограмму превращения остатка в N-ичную цифру, достаточно будет просто передавать основание системы счисления как еще один параметр. Все, что нужно сделать, — это удалить строки кода, загружающие делитель в регистр ЕВХ. Кроме того, для сохранения значений регистров общего назначения мы добавим команды PUSHAD и POPAD. Окончательную версию подпрограммы, приведенную в листинге 7.3, мы будем использовать в других примерах Листинг 7.3. Программа преобразования числа в строку окончательный вариант)
NumToASCII еах = 32-битное число ebx = основание системы счисления edi = указатель на строку-результат Возвращает заполненный буфер
NumToASCII: pushad xor esi,esi convert_loop: сохраняем все регистры общего назначения в стеке
ESI = 0: это счетчик цифр в стеке
106

Глава 7. Полезные фрагменты кода xor edx,edx div ebx call HexDigit push edx inc esi test eax,eax jnz convert_loop eld write_loop: pop eax stosb dec esi test esi,esi jnz write_loop mov byte [edi],0 popad ret
;EDX = Оделим ЕАХ на ЕВХ , частное в ЕАХ, остаток в EDX преобразуем в ASCII сохраняем EDX в стеке увеличиваем счетчик цифр в стеке все (ЕАХ = 0) если не 0, продолжаем сбрасываем флаг направления DF: запись вперед выталкиваем цифру из стека записываем их в буфер по адресу ES:(E)DI уменьшаем счетчик оставшихся цифр все (ESI = 0) если не 0, переходим к следующей цифре заканчиваем строку нулевым байтом восстанавливаем исходные значения регистров все ! ! !
7.3. Преобразование строки в число Часто бывает нужно прочитать число, то есть извлечь его из строки. Высо­
коуровневые языки программирования предоставляют ряд библиотечных функций для преобразования строки в число (readln, scanf), а мы напишем простенькую функцию такого назначения самостоятельно. Для преобразования одного символа в число мы напишем подпрограмму convert_char, которая преобразует цифры '0'-'9' в числа 0-9, а символы 'A'-'F' и 'а'-Т в числа 10—15 (ОхА-OxF). Единственным входным, он же выходной, параметром будет регистр AL, в который перед вызовом подпрограммы нужно будет загрузить один символ. В результате работы подпрограммы в этом же регистре окажется числовое значение. Давайте рассмотрим эту подпрограмму. convert_char: вычитаем из символа код нуля если разность меньше 10, то была десятичная цифра — больше ничего ненужно делать команда JB — переход, если меньше иначе — была буква add al,'0' ;AL = исходная буква and al,0x5f приводим ее к верхнему регистру sub al,'0' emp al, 10 jb done
107

Ассемблер на примерах. Базовый курс sub a l , ' A ' - 1 0 получаем диапазон отвернуть нужно значение 0-15. Если буква больше F, то очищаем 4 старших бита AL d o n e : r e t возвращаемся Наша программа пока не предусматривает никакой проверки корректности входных данных мы просто предполагаем, что байт на входе представляет десятичную цифру либо латинскую букву в верхнем или нижнем регистре. Понятно, что против некорректного вызова она беззащитна. Сначала мы вычитаем из исходного символа код цифры нуль. Если результат попадает в диапазон 0-9, то нужное число уже получено переходим к метке done; если нетто считаем символ буквой. Благодаря хорошо продуманной таблице ASCII (рис. 1.2) код строчной буквы отличается от кода соответствующей ей заглавной только единицей в пятом бите (считая с нулевого, поэтому для перевода буквы в верхний регистр достаточно сбросить этот бит (маска 0x5F). Следующий шаг — вычитанием сдвинуть значение в другой диапазон, получив из 'А' — ОхА, из 'В' — ОхВ и т.д. И, наконец, последняя операция AND ограничивает диапазон возвращаемых значений младшими четырьмя битами — числами от 0x00 до OxOF. Теперь подумаем, как реализовать функцию для преобразования чисел со знаком. Довольно непростая задача, номы ее упростим. Договоримся, что запись отрицательных чисел, и только их, будет начинаться с минуса, и только одного. То есть если вначале строки стоит символ минус, то, значит, перед нами отрицательное число. Преобразование отрицательного числа выполняется точно также, как и положительного, только в самом конце подпрограммы мы выполним операцию
NEG (отрицание. Займемся разработкой самого алгоритма преобразования. Впервой главе мы обсуждали представление любого числа в виде а = a n
*z n
+ a n-1
*z n-1
+ ... + a
1
*z
1
+ a
0
*z° (n — это количество цифр) Например, десятичное число 1234 может быть записано так
1234 = 1*10 3
+ 2*10 2
+ 3*10' + 4*10° Аналогично, шестнадцатеричное значение 0x524D может быть записано как
(524D)
16
= 5*16 3
+ 2*16 2
+ 4*16' + 13*16° = 21 069 На первый взгляд кажется, что сама формула подсказывает алгоритм преобразуем каждую цифру в число по программе convert_char, умножаем на соответствующую степень основания, складываем и получаем в итоге нужное число. Но со второго взгляда становится видно, что степени основания мы не
108

Глава 7. Полезные фрагменты кода узнаем, пока не прочтем все цифры и по их количеству неопределим порядок числа. Неуклюжим решением было бы сначала подсчитать цифры, а потом перейти к очевидному алгоритму, номы поступим изящнее. Это же число 1234 может быть записано так
1234 = ((((1)*10 + 2)*10 + 3)*10) + 4 Это означает, что мы можем умножить первую слева цифру на основание, прибавить вторую цифру, снова умножить на основание и т.д. Благодаря этому постепенному умножению нам ненужно заранее знать порядок преобразуемого числа. Рис. 7.3. Блок-схема алгоритма преобразования строки в число Окончательная версия подпрограммы преобразования строки в число приведена в листинге 7.4.
109

Ассемблер на примерах. Базовый курс Листинг 7.4. Программа преобразований строки в число
ASCIIToNum
; esi = указатель на строку, заканчивающуюся символом с
; кодом 0x0
; есх = основание системы счисления
; Возвращает
; еах = число
ASCIIToNum: push esi xor eax,еах xor ebx,ebx cmp byte [esi] jnz .next inc esi
.next: lodsb or al,al j z .done call convert_char imul ebx,ecx add ebx,eax jmp short .next
.done: xchg ebx,eax pop esi cmp byte [esi],'-' jz .negate ret
.negate: neg eax ret сохраняем указатель в стеке
;ЕАХ = 0
;ЕВХ = 0: накопитель для числа число отрицательное если нет, не пропускаем следующий символ пропускаем символ '- ' читаем цифру вконец строки преобразовать в число и сохранить его в AL умножить ЕВХ на ЕСХ, сохранить в ЕВХ сложить и повторить поместить накопленное число в ЕАХ восстановить исходное значение ESI результат должен быть отрицательным да, выполним отрицание нет, положительным — все готово выполняем отрицание все
110

Операционная система Эволюция операционных систем Распределение процессорного времени. Процессы Управление памятью Файловые системы Загрузка системы Ассемблер на примерах. Базовый курс

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