Азы (встроенный ассемблер), Может кому интересно... Опции

[BlackShadow]

От нечего делать опишу основные моменты при программировании на встроенном ассемблере в Паскале.

Есть 2 способа задействовать эту замечательную возможность:

1. Заключить код на ассемблере между словами asm и end
2. Написать процедуру с указанием директивы Assembler, что в принципе не сильно отличается от первого варианта, т.к. код по прежнему находится между asm и end

Зачем это нужно?
Ну, на самом деле применений целое море, о чём можно убедиться полистав этот раздел форума.

Рассмотрим вопрос адресации в реальном режиме (именно он используется "by def" при компиляции в BP).

Адрес состоит из двух частей: сегментной части и смещения. Обе части являются 16-ти разрядными двоичными числами или, что на практике и применяется, 4-х разрядными шестнадцатиричными.

Рассмотрим пример и на нём разберёмся, что и какая часть значит:

Пусть сегментная часть (далее Seg) = $ABCD, а смещение (далее Ofs) = $1234. Это означает, что эта пара Seg:Ofs хранит следующий адрес Seg * $10 + Ofs = $ABCD * $10 + $1234 = $ABCD0 + $1234 = $ACF04. Как легко заметить, пользуясь таким способом адресации мы можем указать адрес любой ячейки памяти в пределах первого мегабайта ($00000..$FFFFF) и даже чуть-чуть больше, но это не имеет значения, т.к. процессор в реальном режиме даёт доступ только к первому МБ.

Возникает естественный вопрос: а зачем нужен этот геморрой, и почему нельзя просто указывать полный адрес? А вот нельзя. А потому, что процессор при работе с памятью опирается на информацию, которая хранится в его регистрах, а т.к. мы используем 16-битный вариант команд, то, соответственно, в 1 регистр более 16 бит (4 16-ричные цифры) не впихнуть. Поэтому и приходится использовать 2 регистра: сегментный и какой-нибудь, который можно использовать для адресации.

Рассмотрим предназначение регистров процессора:

• CS - Code Segment, сегмент кода. В этом регистре хранится сегментная часть адреса исполняемой команды.
• DS - Data Segment, сегмент данных. Тут хранится сегментная часть адреса тех данных программы, которыми она пользуется в текущий момент.
• SS - Stack Segment, сегмент стека. Хранит -||- области памяти, которая сейчас используется как стек.
• ES - Extended Segment, дополнительный сегмент. Используется для того, чтобы программа могла использовать данные хотя бы из 2 участков памяти, которые не находятся рядом (например, в DS $1000, а в ES - $F000), а так же для некоторых команд, но об этом не сейчас.
• AX - Accumulator, регистр общего назначения, т.е. можно его использовать как угодно, но отведён на математические вычисления, т.к. некоторые команды требуют того, чтобы их операнд находился именно в AX, а некоторые команды с использованием AX выглядят на байт короче после компиляции, нежели с каким-нибудь другим регистром.
• BX - Base, тоже регистр общего назначения, но его конёк в том, что его можно использовать для адресации, т.е. число, хранящееся в нём при необходимости может быть расценено, как часть адреса - смещение.
• CX - Counter, выделяется от остальных общих регистров тем, что команда реализации циклов (ну ещё пара, но куда реже) предполагает свой аргумент именно в CX. Т.е. при программировании на ассемблере CX выступает в роли Паскалевского i
• DX - Data. Просто регистр общего назначения. Такой на всякий случай - ничего специфического в нём нет.
• IP - Instruction Pointer. Этот регистр хранит смещение текущей команды, т.е. пара CS:IP указывает на команду в памяти, которая вот-вот будет выполнена процессором.
• SP - Stack Pointer. Хранит смещение верхушки стека (SS:SP). Очень важное значение, т. к. процессор при обработке команд работы со стеком рассчитывает именно на этот регистр.
• BP - Base Pointer. Регистр для хранения смещения. Как правило используется в процедурах для адресации переменных через стек. Отличается от SP тем, что процессору его значение не особо интересно, но адресация через этот регистр идёт так же по SS (если не указать другой).
• SI, DI - Source Index и Destination Index. Два регистра предназначенные для хранения смещений. Особенностью их является то, что некоторые команды рассчитывают, что их операнды хранятся именно тут.

Средствами паскаля мы можем подучить текущие значения регистров DS (функция DSeg), SS (SSeg) и CS (CSeg).

Теперь давайте рассмотри примитивный набор команд.

mov dst, src копирует значение src в dst. Есть один важный момент: командой mov нельзя скопировать значение одной переменной в другую за один приём.

Примеры: (Показать/Скрыть)

mov AX, 4
mov BX, AX
mov [A], BX
mov [word ptr B], 5

Заметим, что в последнем примере появились слова word ptr. Это необходимо для того, чтобы указать компилятору как что надо расценивать его операнды (в нашем случае - слова), т. к. ни имя переменной ни число 5 не говорят ему о размерах операндов.

inc p увеличивает на 1 значение операнда. После компиляции эта команда занимает меньше места чем команда прибавления единицы.

Примеры: (Показать/Скрыть)

inc DX
inc [word ptr C]
inc 5 ; естественно ошибка.

dec p соответственно уменьшает операнд на 1.

add dst, src прибавляет к src значение dst. Результат сохраняется в dst, так что просто число там написать нельзя.

Примеры: (Показать/Скрыть)

add AX, BX
add AX, [d]
add [byte ptr E], 127

sub dst, src вычитает из dst значение src.

mul n умножает значение регистра AL (AX) на n. Если n размером в 1 байт, то происходит следующее: AX = AL * n, если же слово, то старшие 16 бит произведения сохраняются в DX, а младшие в AX, т. е., умножив AX=$1010 на $100 получим в DX $0010 и в AX $1000.

Примеры: (Показать/Скрыть)

mul BL
mul [word ptr F]

div n делит значение в AX (DX:AX, как в команде mul) на n. При этом остаток сохраняется в AH (DX), а целая часть от деления в AL (AX).

Например: (Показать/Скрыть)

mov AX, 11
mov BX, 3
mov DX, 0	; AX=11, BX=3, DX=0
div BX	; AX=3, BX=3, DX=2
div BL	; AL=3, AH=0, BX=3, DX=2

cmp a, b - сравнивает значения a и b и устанавливает флаги процессора в соответствии с результатом сравнения.

Например: (Показать/Скрыть)

cmp AX, BX
cmp [word ptr G], 4

jmp L - команда безусловного перехода на метку L. То что в BP называется GoTo.

Например: (Показать/Скрыть)

JMP L

j<cc> L - серия команд условного перехода. Тут <cc> определяет условия перехода:

• jz, je - переход, если равно
• jb - переход, если меньше (числа расцениваются как беззнаковые)
• ja - переход, если больше (числа расцениваются как беззнаковые)
• jl - переход, если меньше (числа расцениваются как знаковые)
• jg - переход, если больше (числа расцениваются как знаковые)

Также допускаются комбинации с буквой n (отрицание) и e (равенство).

Например: (Показать/Скрыть)

cmp AX, 5
jnae L1	; Переход, если не более или равно. Проще JB
jz L2		; Если AX = 5

Так же есть несколько иных условий перехода, но данном этапе они не нужны.

Рассмотрим ещё команду loop L она сравнивает CX с 0 и, если он отличен, то уменьшает его на 1 и делает переход на указанную метку.

Пример: (Показать/Скрыть)

  mov CX, 5
L3:
  inc AX
  loop L3	; Пять раз увеличит AX на 1

Теперь для закрепления сказанного рассмотрим реализацию вычисления факториала:

Function Factorial(n: Integer): Integer; Assembler;
Asm
	mov CX, [n]	{Проверим, может n<0?}
	cmp CX, 0	{Сравним с 0}
	jl @@1		{Если меньше, то считать не будем}
	mov AX, 1	{Начальное произведение}
@@2:			{В CX мы уже загрузили кол-вл итераций, так что к циклу готовы}
	mul CX		{Домножим текущее произведение на значение счётчика}
	loop @@2	{И продолжим цикл}
	jmp @@3		{Произведение вычислено - можно выходить из функции}
@@1:			{А, если попросили вычислить факториал отрицательного числа}
	mov AX, 0	{То вернём 0}
End;

Var n: Integer;
Begin
  ReadLn(n);
  WriteLn(Factorial(n))
End.

Стоит объяснить ещё и то, как возвращаются значения функций. Это всё зависит от типа результата:
Byte, Char - через AL
Word, Integer - через AX
LongInt - старшая часть в DX, а младшие 16 бит в AX.
Pointer - сегментная часть в DX, смещение - AX.
Остальные типы возвращаются более извращённым способом...

Так же отмечу, что убрав проверку на <0 можно переписать эту функцию так:

Function Factorial(n: Integer): Integer; Assembler;
Asm
	mov CX, [n]
	mov AX, 1
@@1:
	mul CX
	loop @@1
End;

Правда проблема переполнения остаётся, но зато покажите мне компилятор, который стандартное

Function Factorial(n: Integer): Integer;
Var
  i, Res: Integer;
Begin
  Res:=1;
  For i:=2 To n Do
    Res:=Res*n
  Factorial:=Res
End;

скомпилирует вот так вот красиво...

[BlackShadow]

Голова болит, работа достала... Ну как тут не вспомнить про Assembler?

Строковые команды

Из названия можно было бы подумать, что в assembler'е тоже есть что-то "стандартное" типа Length или Copy. А вот и нет. Эти команды просто довольно часто используются для работы со строками или просто с цепочками данных.

Но для начала объясню действие ещё 2 команд: LDS/LES <Reg>,<Src>, которые загружают из 4-ёх байтового указателя значения в регистр DS/ES соответственно (сегментную часть указателя) и в указанный регистр вторую часть указателя - смещение. Эти команды довольно удобны, т.к. все указатели Pascal'я имеют именно такую структуру.

Вернёмся к строковым командам. Общий принцип таков:

• Команды предполагают, что их параметры находятся в регистрах ES:DI, DS:SI или AL/AX (зависит от самой команды).
• Команда выполняет своё действие (зависит от самой команды)
• изменяет регистры SI, DI если требуется. Причём, если DF = 0, то происходит увеличение, если DF = 1, то наоборот - уменьшение.
• величина, на которую изменяются SI, DI зависит от размера параметра: слово - на 2 байта, байт - на 1.

Теперь рассмотрим сами команды.
LODSB/LODSW загружает в AL или AX соответственно (последняя буква в названии команд этого типа и обозначает размер операнда: W - слово, B - байт) значение из DS:SI. Для наглядной иллюстрации напишем функцию StrLen

Function StrLen(s:PChar):Integer;Assembler;
Asm
	PUSH DS		{Сохраним DS На всякий случай}
	LDS SI,[s]	{Загрузим в DS:SI адрес источника}
	MOV CX,0	{В CX будем считать длину строки}
	CLD		{Укажем направление - в сторону возрастания адресов}
@@1:
	LODSB		{Загрузим в AL}
	CMP AL,0	{В AL маркер конца строки?}
	JE @@2		{Да - закончим}
	INC CX		{Увеличим длину строки}
	JMP @@1		{И перейдём к следующему символу}
@@2:
	MOV AX,CX	{Результат в AX}
	POP DS		{Восстановим DS}
End;

Команда STOSB/STOSW сохраняет значение AL/AX по адресу ES:DI. Пример - функция, обнуляющая строку:

Procedure StrNull(s:PChar);Assembler;
Asm
	LES DI,[s]	{Загрузим адрес приёмника}
	MOV AL,0	{Подготовим к сохранению маркер конца строки}
	STOSB		{Сохраним его на место самого первого символа в строке}
End;

MOBSB/MOVSW копируют байт/слово из DS:SI в ES:DI. Для примера возьмём процедуру копирования строки:

Procedure StrCopy(Dst:PChar;Src:PChar);Assembler;
Asm
	LDS SI,[Src]	{Загрузим адрес источника}
	PUSH DS		{Передадим адрес этой строки для вычисления её длины}
	PUSH SI		{Сначала сегментную часть, затем смещение}
	CALL StrLen	{Вызов StrLen}
	CMP AX,0	{Длина не нулевая ли?}
	JNZ @@0		{Если нет, то продолжим}
	LDS SI,[Dst]	{Иначе загрузим адрес приёмника}
	PUSH DS		{И запишем в него пустую строку}
	PUSH SI
	CALL StrNull
	JMP @@2		{На чём и выйдем из функции}
	MOV CX,AX	{Переместим длину строки в счётчик}
	LES DI,[Dst]	{Подготовим адрес приёмника}
	CLD		{Укажем направление}
@@1:
	MOVSB		{Скопируем 1 байт}
	LOOP @@1	{И перейдём к следующему}
@@2:
End;

SCASB/CMPSW Сравнивает значение источника с AL/AX. Для примера перепишем StrLen:

Function StrLen(s:PChar):Integer;Assembler;
Asm
	PUSH DS
	LDS SI,[s]
	MOV AL,0	{Символ, который мы ищем}
	MOV CX,0	{Длина строки}
	CLD		{Направление}
@@1:
	SCASB		{Сравниваем}
	JE @@2		{Нашли! -> к выходу}
	INC CX		{Увеличиваем длину строки}
	JMP @@1		{и т.д.}
@@2:
	MOV AX,CX	{Результат в AX}
	POP DS
End;

CMPSB/CMPSW сравнивают два байта/слова из DS:SI и ES:DI и в соответствии с этим устанавливают флаги. Как пример можно привести сравнение строк, но мне, если честно, откровенно влом сейчас заниматься такими извратами.

WARNING!!! Все примеры приведённые тут являются чисто демонстрационными! Никакого практического применения они иметь не должны, т. к. далеко не оптимальны.

А вот намного всё упрощают и улучшают префиксы повторений REPxx. Возможные варианты: REP/REPE/REPNE (ну или REP/REPZ/REPNZ, если так кому больше нравится). Команда с таким префиксом выполняется CX раз, если тому не помешает условие. Следующий пример уже можно использовать в жизни:

Function StrLen(s:PChar):Integer;Assembler;
Asm
	PUSH DS
	LDS SI,[s]
	MOV AL,0
	MOV CX,$FFFF
	CLD
	REPNZ SCASB	{Сканировать 65535 раз, пока не наткнёмся на 0}
	MOV AX,$FFFF
	SUB AX,CX
	POP DS
End;

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

Ну и напоследок приведу пример, в котором команда из этого набора используется не для работы со строками:

Procedure VsyoNeboVPopugayah;Assembler;
Asm
	MOV AX,$B800	{Адрес видео буфера для текстового режима}
	MOV ES,AX	{Занесём в ES}
	MOV DI,0	{Обнулим DI => ES:DI указывает на видеобуфер}
	MOV AX,3042h	{30h - код '0' в ASCII, 24h - красным по синему}
			{Возможно, надо написать MOV AX,4230h - не помню я}
	MOV CX,2000	{80*25 = 2000 слов в видеобуфере}
	CLD		{Направление}
	REP STOSW	{Сохраняем 2000 попугайчиков}
End;

Ну вот вроде и всё, что я хотел сказать на эту тему...