Презентация на тему Арифметические и логические команды языка Ассемблер. Битовые команды

двух операндов, как и команда MOV:
Команда ADD складывает оба

операнда и записывает результат в о1, предыдущее значение которого теряется.
Точно так же работает команда вычитания — SUB:

ADD о1, о2

Результат, o1-o2, будет сохранен в o1, исходное значение o1 будет потеряно.

SUB оl, o2

mov ax, 8 ; заносим в АХ число 8
mov сх, 6 ;заносим в СХ число 6
mov dx, сх ;копируем СХ в DX, DX = 6
add dx, ax ;DX = DX + АХ

Команда ADD сохранит результат DX + АХ в регистре DX, а исходные значения АХ и СХ останутся нетронутыми.

;AX = AX + 8
sub cx,

bp ; CX = CX - BP
add number, 4 ;добавляем значение 4
;к переменной number
sub number, 4 ;number = number — 4
sub number, al ;вычитаем значение регистра AL
;из "number"
sub ah,al ;вычитаем AL из АН, результат
;помещаем в АН

Что произойдет, если сначала занести в AL (8-разрядный регистр) наибольшее допустимое значение (255), а затем добавить к нему 8?

mov al, 255 ; заносим в AL значение 255,
;то есть OxFF
add al, 8 ;добавляем 8

В результате в регистре AL мы получим значение 7.
Девятый, ≪потерянный≫, бит скрыт в регистре признаков,
а именно в флаге CF — признак переноса.

;AX = OxFFFF
mov dx, 0 ;DX =

0
add ax, 8 ;AX = AX + 8
adc dx, 0 ;добавляем О с переносом к DX

Команды ADC (Add With Carry — сложение с переносом) и SBB (Subtract With Borrow — вычитание с займом):
ADC оl, o2 ;ol = оl + о2 + CF
SBB ol, o2 ;ol = ol - о2 - CF
Эти команды работают так же, как ADD и SUB, но соответственно добавляют или вычитают флаг переноса CF.

В контексте арифметических операций очень часто используются так называемые пары регистров.
Пара — это два регистра, использующихся для хранения одного числа.
Часто используется пара DX:AX — обычно при умножении.
Регистр АХ хранит младшие 16 битов числа, a DX — старшие 16 битов.

После выполнения ADC флаг CF будет добавлен к DX (DX теперь равен 1).
Результат сложения OxFFFF и 8 (0x10007) будет помещен в пару DX:AX (DX=1,AX=0007).

x:integer;
begin
asm
mov x, 5
mov eax,

7
add eax, x
mov x, eax
end;
Label1.Caption:=IntToStr(x);
end;

b, c;
__asm
{
mov a, 5

mov b, 7
mov eax, a
add eax, b
mov c, eax
}
cout << "c = " << a << " + " << b << " = " << c;

инкрементирования и декрементирования.
Команда INC добавляет, a DEC вычитает единицу

из единственного операнда.
Допустимые типы операнда — такие же, как у команд ADD и SUB, а формат команд таков:

INC o1 ;o1 = o1 + 1
DEC o1 ;o1 = o1 - 1

Ни одна из этих инструкций не изменяет флаг CF.

add al,1 ;AL = AL + 1
inc al ;AL = AL + 1
Inc number ;number = number+1

коде.
Один байт может содержать числа в диапазоне от 0

до 255. Код дополнения
заменяет этот диапазон другим — от -128 до 127. Диапазон от 0 до 127 отображается сам на себя, а отрицательным числам сопоставляется диапазон от 128 до 255: числу -1 соответствует число 255 (OxFF), -2 — 254 (OxFE) и т.д.
Число -50 будет представлено как 206.

mov ax,OxFFFA ;AX = -6, то есть 65530 или OxFFFA
mov dx,7 ;DX = 7
add ax,dx ;AX = AX + DX

Дополнительный код может быть расширен до 2 байтов (от 0 до 65535). Он
будет охватывать диапазон чисел от -32768 до 32767. Если дополнительный код
расширить до 4 байтов, то получим диапазон от -2 147 483 648 до 2 147 483 647.

Рассмотрим, как это происходит, на примере суммы чисел -6 и 7 в дополнительном коде из 2 байтов. Число 7 будет отображено само в себя, а число -6 будет представлено числом 65 536 — 6 = 65 530 (OxFFFA).

Мы получим результат 65 530 + 7 = 65 537 = 0x10001, который не помещается
в регистре АХ, поэтому будет установлен флаг переноса. Но если мы его проигнорируем, то оставшееся в АХ значение будет правильным результатом!

не нужно преобразовывать их вручную в дополнительный код:
mov ax,

-6 ;АХ = -6
mov dx, -6 ;DX = - 6
add ax,dx ;AX = AX + DX

Результат: 0xFFF4 (установлен также флаг CF, но мы его игнорируем). В десятичной системе 0xFFF4 = 65 524. В дополнительном коде мы получим правильный результат: -12 (65 536 — 65 524 = 12).

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

Команда NEG

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

neg ах ;изменяет знак числа, сохраненного в АХ
neg bl ;то же самое, но используется 8-битный регистр bl
neg number ;изменяет знак переменной number

в трех различных форматах — в зависимости от операнда:
В

8-разрядной форме операнд может быть любым 8-битным регистром или адресом памяти. Второй операнд всегда хранится в AL. Результат (произведение) будет записан в регистр АХ.

MUL r/m8
MUL r/ml6
MUL r/m32

(r/m8) * AL -> АХ

В 16-разрядной форме операнд может быть любым 16-битным регистром или адресом памяти. Второй операнд всегда хранится в АХ. Результат сохраняется в паре DX:AX.

(r/ml6) * АХ -> DX:AX

В 32-разрядной форме второй операнд находится в регистре ЕАХ, а результат записывается в пару EDX:EAX.

(r/m32) * ЕАХ -> EDX:ЕАХ

в регистрах ВН и CL, результат сохранить в регистр

АХ:

mov al, bh ;AL = ВН — сначала заносим в AL второй операнд
mul cl ;АХ = AL * CL — умножаем его на CL

Результат будет сохранен в регистре АХ.

Пример 2: вычислить 4862, результат сохранить в DX:AX:

mov ax, 486 ; АХ = 486
mul ах ; АХ * АХ -> DX:AX

Пример 3: вычислить диаметр по радиусу, сохраненному в 8-битной переменной radius, результат записать в 16-битную переменную diameter:

mov al, 2 ; AL = 2
mul radius ; AX = radius * 2
mov diameter,ax ; diameter <- AX

со знаком и может использовать один, два или три

операнда.
Когда указан один операнд, то поведение IMUL будет таким же, как и команды MUL, просто она будет работать с числами со знаком.

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

imul edx,ecx ;EDX = EDX * ECX
imul ebx, sthing ;умножает 32-разрядную переменную sthing
;на ЕВХ, результат будет сохранен в ЕВХ
imul есх,6 ;ЕСХ = ЕСХ * 6

Если указано три операнда, то команда IMUL перемножит второй и третий операнды, а результат сохранит в первый операнд. Первый операнд — только регистр, второй может быть любого типа, а третий должен быть только непосредственным значением:

imul ebx,[sthing],9 ;умножаем переменную "sthing" на 9,
;результат будет сохранен EBX
imul ecx,edx,ll ;ЕСХ = EDX * 11

может быть представлена в трех различных форматах в зависимости

от типа операнда:

DIV r/m8
DIV r/ml6
DIV r/m32

Операнд служит делителем, а делимое находится в фиксированном месте (как
в случае с MUL).

В 8-битной форме переменный операнд (делитель) может быть любым 8-битным регистром или адресом памяти. Делимое содержится в АХ. Результат cохраняется так: частное — в AL, остаток — в АН.

АХ / (r/m8) -> AL, остаток -> АН

В 16-битной форме операнд может быть любым 16-битным регистром или адресом памяти. Второй операнд всегда находится в паре DX:AX. Результат сохраняется в паре DX:AX (DX — остаток, АХ — частное).

DX:AX / (r/ml6) -> АХ, остаток -> DX

В 32-разрядной форме делимое находится в паре EDX:EAX, а результат записывается в пару EDX:EAX (частное в ЕАХ, остаток в EDX).

EDX:EAX / (r/m32) -> ЕАХ, остаток -> EDX

чисел со знаком, синтаксис ее такой же, как у

команды DIV.

Пример 1: разделить 13 на 2, частное сохранить в BL, а остаток в — ВН:

mov ах,13 ;АХ = 13
mov cl,2 ;CL = 2
div cl ;делим на CL
mov bx,ax ;ожидаемый результат находится в АХ, копируем в ВХ

Пример 2: вычислить радиус по диаметру, значение которого сохранено в 16-битной переменной diameter, результат записать в radius, а остаток проигнорировать.

mov ax, diameter ;AX = diameter
mov bl, 2 ;загружаем делитель 2
div bl ;делим
mov radiusl, al ;сохраняем результат

— o1 и о2. Результат сохраняется в операнде o1.

Типы операндов такие же, как у команды ADD: операнды могут быть 8-, 16- или 32-битными регистрами, адресами памяти или непосредственными значениями.
AND o1, o2

Следующий пример вычисляет логическое И логической единицы и логического
нуля (1 AND 0).
mov al, 1 ;AL = one
mov bl, 0 ;BL = zero
and al, bl ;AL = AL and BL = 0
Команда and производит поразрядное логическое умножение операндов и записывает результат на место первого операнда:
mov al, 1100b ;al=00001100b
and al, 1010b ;al=00001000b

— o1 и о2.
Результат сохраняется в операнде o1. Типы

операндов такие же, как у команды AND.
OR o1, o2

Простой пример установки наименее значимого бита (первый справа) переменной mask в 1.
or mask,1

Команда OR производит поразрядное логическое сложение операндов и записывает результат на место первого операнда.
mov al, 1100b ;al=00001100b
or al, 1010b ;al=00001110b

который может быть регистром или памятью. Соответственно команда может

быть записана в трех различных форматах:
NOT r/m8
NOT r/ml 6
NOT r/m32

Следующий пример демонстрирует различие между операциями NOT и NEG:

mov al,00000010b ;AL = 2
mov bl,al ;BL = 2
not al ;после этой операции мы получим
;11111101b = OxFD (-3)
neg bl ;a после этой операции результат будет
;другим: 11111110 = OxFE (-2)

или вправо. Одним из операндов этих команд является количество

сдвигов cnt. Оно либо равно 1, либо определяется содержимым регистра CL (при этом CL сохраняет своё содержимое после операции).

Логические сдвиги - команды сдвига, где участвуют все биты первого операнда, при этом бит, уходящий за пределы ячейки, заносится в флаг CF, а с другого конца в операнд добавляется ноль.
Логический сдвиг влево (shift left): SHL
Логический сдвиг вправо (shift right): SHR

mov al, 01000111b
shl al,1 ;CF=0, al=10001110b
mov al, 01000111b
shr al,1 ;CF=1, al=00100011b
mov bh, 0011100b
mov cl,3
shl bh,cl ;CF=1, al=11000000b

Логические сдвиги

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

Арифметический сдвиг влево (shift arithmetic left): SAL
Арифметический сдвиг вправо (shift arithmetic right): SAR

mov ah,10001110b
sar ah,1 ;CF=0, al=11000111b
mov ah,10001110b
sal ah,1 ;CF=1, ah=00011100b

Арифметические сдвиги

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

mov ax,88        
sar ax,2 ;(ax) разделить на 2 в второй степени, то есть на 4