используй тэг "code"

9)Адресование со смещением относительно PC(Program Counter)

Обозначение <ea>: x(PC)

Синтаксис: move.x n(pc), Dy
где х -- тип данных byte, word или longword
рс -- значение Program Counter в момент выполнения инструкции
n -- величина смещения
Dy -- регистр данных D0-D7

Примечание: величина смещения(n) имеет тип word, также sign, т.е. изменяется в диапазоне -7FFF..+7FFF.

Пример: move.l $100(pc), d0 копирует данные(longword), находящиеся по смещению PC+$102(102 потому что х имеет тип word).

10)Непосредственное адресование

Обозначение <ea>: #x

Синтаксис: move.x #n, Dy
где х -- тип данных byte, word или longword
#n -- обычное число, например $12
Dy -- регистр данных D0-D7

Пример: move.w #$1234, d0 копирует число $1234 в регистр D0

Т.к. варианты адресования рассматривались на примере инструкции MOVE, захватим оставшиеся ее варианты.
11)Быстрое копирование

Синтаксис: moveq #x, Dy
где х -- обычное число, тип byte, при значении больще чем $7F считается отрицательным
Dy -- регистр данных D0-D7

Пример: moveq #$26, d4 копирует число $26 в регистр D4, причем полностью изменяет его. Смотри ниже

12)Копирование в адресный регистр

Синтаксис: movea.х #$n, Ay
где n -- адрес, который надо поместить в адресный регистр
х -- тип word или longword
Ay -- адресный регистр A0-A7(да, да SP тоже используется)

Пример: movea.l #$00FFFF0E, A3 помещает в регистр A3 значение(адрес) #$00FFFF0E

Все варианты адресования, характерные именно для инструкций MOVE будут приведены позже

Добавлено (02.07.2009, 22:12)
---------------------------------------------

Но, в этой подпрограмме изменяется регистр d0:

То есть мы видим, что по окончании подпрограммы в регистре d0 будет значение 1, а нам нужно $12. И поэтому,
чтобы сохранить значение $12 в памяти, но и используя в то же время регистр мы и используем SP. Вот обновленный
пример:

Отредактировал первые посты, теперь сначала идут описания вариантов адресования на примере MOVE, в будущем будем просто на них ссылаться(чтобы не писать по несколько раз один и тот же пример)

1)Обычное суммирование ADD
Складывает между собой 2 операнда и записывает результат во втором

Синтаксис: 1)add.n <ea>, Dn
2)add.n Dn, <ea>

Варианты адресования: 1)<ea>: Dn, An, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l, x(PC), x(PC,xr.s), #x
2)<ea>: (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Тип данных: byte, word или longword

Пример:

Если берутся данные из RAM и тип данных word, то считываются левые 2 байта, если байт -- левый 1 байт

2)Суммирование с адресным регистром ADDA
Складывает операнд со значением в адресном регистре.

Синтаксис: ADDA <ea>, An

Варианты адресования <ea>: Dn, An, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l,
x(PC), x(PC,xr.s), #x

Тип данных: Word, longword

Пример:

Добавлено (08.07.2009, 22:25)
---------------------------------------------
3)Быстрое суммирование ADDQ
Работает также как и add, за исключением того, что в качестве первого операнда ВСЕГДА используется число,
отсутствует тип данных и инструкция очень мала(2 байта)

Синтаксис: ADDQ #<data>,<ea>
<data> -- число от 1 до 8

Варианты адресования <ea>: Dn, An, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Пример:

4)Непосредственное суммирование ADDI
Прибавляет натуральное число к операнду

Синтаксис: ADDI #x,<ea>

Варианты адресования <ea>: Dn, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Тип данных: Byte, Word, longword

Пример:

5)Обнуление CLR
Обнуляет операнд

Синтаксис: CLR <ea>

Варианты адресования <ea>: Dn, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Тип данных: Byte, word, longword

Пример:

6)Сравнение CMP
Сравнивает регистр данных с операндом. Ни регистр, ни операнд после инструкции не изменяются. Часто
используется в связке с условными переходами типа Bcc(будут рассмотрены позже)

Синтаксис: CMP <ea>,Dn

Варианты адресования <ea>: Dn, An, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l,
x(PC), x(PC,xr.s), #x

Тип данных: Byte, word, longword

Пример:
cmp.w d0, d1 ; сравнение двух регистров
beq.s label ; переход, если регистры равны
...........

Добавлено (08.07.2009, 22:25)
---------------------------------------------
7)Сравнение с адресным регистром CMPA
Сравнивает адресный регистр с операндом. Ни регистр, ни операнд после инструкции не изменяются. Часто
используется в связке с условными переходами типа Bcc(будут рассмотрены позже)

Синтаксис: CMPA <ea>,An

Варианты адресования <ea>: Dn, An, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l,
x(PC), x(PC,xr.s), #x

Тип данных: Word, longword

Пример смотри в пункте 6 -- Сравнение

[b8)Сравнение с числом CMPI[/b]
Сравнивает операнд с натуральным числом. Ни регистр, ни операнд после инструкции не изменяются. Часто
используется в связке с условными переходами типа Bcc(будут рассмотрены позже)

Синтаксис: CMPI #<data>, <ea>

Варианты адресования <ea>: Dn, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Тип данных: Byte, word, longword

9)Деление(Signed) DIVS
Делит регистр данных на операнд. Регистр имеет тип longword, операнд всегда word. Результат сохраняется
в регистре данных следующим образом: целая часть записывается в правых 2-х байтах, остаток -- в левых.

Синтаксис: DIVS <ea>,Dn

Варианты адресования <ea>: Dn, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l, x(PC),
x(PC,xr.s), #x

Тип данных: word

[bi]Пример:[/i]

10)Деление(Unsigned) DIVU
Работает также как и DIVS, за исключением того, что регистр cчитается Unsigned.

11)Умножение(Signed) MULS
Умножает регистр данных с операндом(оба типа word). Результат размером 4 байта записывается в регистр данных

Синтаксис: MULS <ea>,Dn

Варианты адресования <ea>: Dn, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l, x(PC),
x(PC,xr.s), #x

Тип данных: Word

Пример:

12)Умножение(Unsigned) MULU
Работает также как и MULS, за исключением того, что регистр cчитается Unsigned.

13)Вычитание SUB, SUBA, SUBI, SUBQ имеют те же свойства, что и подобные инструкции сложения, за исключением того,
что здесь выполняется не сложение, а вычитание :Р Поэтому смотрим выше в инструкции сложения.

14)Тест TST
Сравнивает операнд с нулем. Часто используется в связке с условными переходами типа Bcc(будут рассмотрены позже)

Синтаксис: TST <ea>

Варианты адресования <ea>: Dn, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Тип данных: Byte, word, longword

Эти инструкции копируют данные из одного места в другое

1)Замена EXG
Меняет местами содержимое двух регистров

Синтаксис: EXG Rx,Ry

Варианты адресования (Rx и Ry): Dn, An

Тип данных: Longword

Пример:

2)Загрузка адреса LEA
Записывает адрес метки программы в адресный регистр. Часто используется, когда нужно, чтобы программа
не зависела от смещения самой метки.

Синтаксис: LEA <ea>,An

Варианты адресования(<ea>): (An), x(An), x(An,xr.s), label.w, label.l, x(PC), x(PC,xr.s)

Тип данных: Longword

Пример:

3)Копирование MOVE
Копирует содержимое одного регистра(ячейки памяти) в другой регистр или ячейку памяти.

Синтаксис: MOVE <ea>,<ea>

Варианты адресования(<ea>): (для источника) Dn, An, (An), (An)+, -(An), x(An), x(An,xr.s),
label.w, label.l, x(PC), x(PC,xr.s), #x
Варианты адресования(<ea>): (для принимающего) Dn, (An), (An)+, -(An), x(An), x(An,xr.s),
label.w, label.l

Тип данных: byte, word, longword

Пример: смотри в главе "методы адресования"

Добавлено (16.07.2009, 20:21)
---------------------------------------------
4)Копирование в адресный регистр MOVEA
Копирует содержимое операнда в адресный регистр. Допускаются только данные типа word или longword.

Синтаксис: MOVEA <ea>,An

Варианты адресования(<ea>): Dn, An, (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l,
x(PC), x(PC,xr.s), #x

Тип данных: word, longword

Примечание: Большинство компиляторов при указании принимающего операнда как адресный регистр,
автоматически заменяют MOVE на MOVEA.

Пример: смотри в главе "методы адресования"

5)Множественное копирование MOVEM
Копирует группу регистров в память за один раз или наоборот. Инструкция часто используется для записи
регистров в SP и последующего оттуда копирования обратно по регистрам. Т.о. можно временно хранить там
содержимое регистров.

Синтаксис: 1)MOVEM <registerlist>,<ea>
2)MOVEM <ea>,<registerlist>

Варианты адресования(<ea>): 1)(An), -(An), x(An), x(An,xr.s), label.w, label.l
2)(An), (An)+, x(An), x(An,xr.s), label.w, label.l, x(PC), x(PC,xr.s)

Тип данных: Word, longword

Пример: смотри в главе "Stack Pointer"

6)Быстрое копирование MOVEQ
Инструкция копирует число в диапазоне от -127 до +127 в регистр данных. Размер ее всего лишь 2 байта,
когда размер например MOVE.L равен 6-ти байтам.

Синтаксис: MOVEQ #<data>,Dn

Варианты адресования: только число

Тип данных: вообще всегда longword, но индекс ".l" не пишется

Пример:

7)Запись адреса в SP. PEA
Инструкция просчитывает адрес операнда и записывает его в SP.

Синтаксис: PEA <ea>

Варианты адресования(<ea>): (An), x(An), x(An,xr.s), label.w, label.l, x(PC), x(PC,xr.s)

Тип данных: Longword

Пример:

8)Замена в регистре SWAP
Меняет данные(word) в регистре местами.

Синтаксис: SWAP Dn

Тип данных: word

Пример:

1)Переходы Bcc
Эти инструкции приводят к переходу к какой-либо части программы. Всего таких типов переходов -- 15. Некото-
рые из них я никогда не использовал, и даже не встречал. Так что те которые я не знаю как работают, просто
отмечу флаги, при которых происходит переход.

Синтаксис: Bcc.s <label>
Bcc.w <label>

Тип данных: byte, word

Начнем сразу с примера. Переходы обычно идут после сравнения двух операндов. Допустим идет сравнение:
cmp.w D0, D1
И после него сразу один из переходов:

Если условие перехода не соответствует тому, что произошло на самом деле, то переход не происходит
и программа идет дальше
cmp.w D0, D1
beq.s label ; пойдет к label, если D0=D1
jmp end ; если D0 не равен D1 программа не выполняет переход, просто идет дальше

2)Переход к подпрограмме BSR
Branch to SubRoutine. Эта инструкция выполняет переход к указанной подпрограмме. Записывает смещение в SP
и после выполнения подпрограммы, происходит возврат.

Синтаксис: BSR.S <label>
BSR.W <label>

Тип данных: word, longword

Пример:

3)Циклы DBcc
Это инструкции-циклы, аналогия как с языками высокого уровня for i=0 to 5 do. Условия для выполнения(сс) смотри
в пункте 1 "Переходы Bcc". Также здесь имеются еще 2 условия, характерных только для цикла.
Инструкция зависит от регистра данных, при каждом попадании на DBcc при прохождении цикла, регистр данных
уменьшается на единицу и происходит переход назад к указанной в инструкции метке. Цикл будет продолжаться
до тех пор пока значение в регистре данных не будет равняться -1.

Синтаксис: DBcc Dn,<label>

Тип данных: word

Пример:

4)Прыжок JMP
Обыкновенный прыжок к метке. Работает также как и move .l label, PC так как по сути JMP просто меняет
значение Program Counter(PC).

Синтаксис: JMP <ea>

Варианты адресования(<ea>): (An), x(An), x(An,xr.s), label.w, label.l, x(PC), x(PC,xr.s)

Тип данных: -

5)Вызов подпрограммы JSR
Jump to SubRoutine. Работает также как и JMP за исключением того, что после прыжка к подпрограмме пи выполнении
инструкции RTS произойдет возврат назад(как и в случае с BSR)

Синтаксис: JSR <ea>

Варианты адресования(<ea>): (An), x(An), x(An,xr.s), label.w, label.l, x(PC), x(PC,xr.s)

Тип данных: -

5)Возврат после подпрограммы RTS
Return from SubRoutine. Эта инструкция используется для возврата PC к месту вызова подпрограммы. Подпрограмма
должна всегда оканчиваться этой инструкцией.

Как работает: при переходе к подпрограмме(JSR или BSR) в Stack Pointer записывается смещение инструкции,
следующей точно после инструкции перехода(JSR или BSR), а в Program Counter записывается смещение самой
подпрограммы. После ее выполнения по команде RTS из Stack Pointer'a копируется смещение инструкции, которое
было записано при переходе к подпрограмме. Таким образом происходит возврат.

Это можно вовсю использовать при поиске нужной части кода в роме. Допустим вы нашли нужную подпрограмму,
но в роме вызовов на нее очень много, не проверять же каждый. Ставим брейкпоинт в дебаггере на нашу процедуру,
ждем пока сработает. Сработал, смотрим, что у нас записано в регистре а7(это и есть Stack Pointer). Пусть
там будет значение $FFFFFFFC. Это адрес в оперативной памяти, где в данный момент находится Stack Pointer.
Открываем просмотрщик памяти(все это время программа остановлена брейкпоинтом, не вздумайте снимать!), смотрим
что у нас записано в $FFFFFFFC. Записанный там адрес и будет адресом, по которому произошел вызов/переход
к подпрограмме.

Добавлено (16.08.2009, 22:40)
---------------------------------------------

------------------

1)Арифметический сдвиг влево ASL
Проделывает арифметический сдвиг данных в регистрах или в памяти влево.
Для того, чтобы сдвинуть число в десятичной системе счисления нужно просто умножить(если сдвиг влево)
или разделить(если вправо) это число на 10. Т.к. процессор понимает только двоичную систему, то естественно
умножать или делить будем на 2 и еще на число шагов сдвига. Т.е. если нужно сдвинуть число 4 на 2 влево, нужно проделать
следующее: 4х2х2 = 16 = $10 = %10000. Итак, смотрим что получилось:
4 = %100
16 = %10000
Вот здесь наглядно виден пример сдвига влево на 2.
Вариантов этого сдвига может быть 3:
1)Сдвиг числа в регистре данных влево. Число шагов записано в другом регистре данных;
2)Сдвиг числа в регистре данных влево. Число шагов задается простым целым числом.
3)Сдвиг числа в памяти влево на один бит.

Синтаксис: ASL Dx,Dy
ASL #<data>,Dy
ASL <ea>

Варианты адресования(<ea>): 3) (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Тип данных: Byte, word, longword

Пример:

2)Арифметический сдвиг вправо ASR
Проделывает арифметический сдвиг данных в регистрах или в памяти вправо. Работает также как и ASL за исключением
того, что сдвиг происходит вправо => вместо умножения проводим деление.
Вариантов этого сдвига может быть 3:
1)Сдвиг числа в регистре данных вправо. Число шагов записано в другом регистре данных;
2)Сдвиг числа в регистре данных вправо. Число шагов задается простым целым числом.
3)Сдвиг числа в памяти вправо на один бит.

Синтаксис: ASR Dx,Dy
ASR #<data>,Dy
ASR <ea>

Варианты адресования(<ea>): 3) (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Тип данных: Byte, word, longword

Пример:

3)Логический сдвиг влево LSL
Проделывает логический сдвиг данных в регистрах или в памяти влево. Работает также как и ASL за исключением
того, что здесь число считается Signed(т.е $FF = -1, $FE = -2 и т.д. до $80). Итак, если мы хотим
сдвинуть число $FF = %11111111 влево на 1 шаг мы получим $FFx(2x1) = $7F = %111111111. Но если считать,
что $FF число негативное($FF = -1), то -1x2x1 = -2 = $FE = %11111110. То есть мы здесь получаем два различных результата.
Первый характерен для арифметических сдвигов, второй - для логических.
Вариантов этого сдвига может быть 3:
1)Сдвиг числа в регистре данных влево. Число шагов записано в другом регистре данных;
2)Сдвиг числа в регистре данных влево. Число шагов задается простым целым числом.
3)Сдвиг числа в памяти влево на один бит.

Синтаксис: LSL Dx,Dy
LSL #<data>,Dy
LSL <ea>

Варианты адресования(<ea>): 3) (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Тип данных: Byte, word, longword

4)Логический сдвиг вправо LSR
Проделывает логический сдвиг данных в регистрах или в памяти вправо. Работает также как и LSL, только
сдвиг проводится вправо, следовательно умножение заменяется делением.
Вариантов этого сдвига может быть 3:
1)Сдвиг числа в регистре данных вправо. Число шагов записано в другом регистре данных;
2)Сдвиг числа в регистре данных вправо. Число шагов задается простым целым числом.
3)Сдвиг числа в памяти вправо на один бит.

Синтаксис: LSR Dx,Dy
LSR #<data>,Dy
LSR <ea>

Варианты адресования(<ea>): 3) (An), (An)+, -(An), x(An), x(An,xr.s), label.w, label.l

Тип данных: Byte, word, longword

Пример: