Список и таблица опкодов

Выполнение инструкции NOP не изменяет ничего.

Опкод инструкции NOP равен 0x00, что значит, что по умолчанию память эмулятора СМ-1800 полностью заполнена NOP-инструкциями. Это значит, что если выполнять код в незаданной памяти, то процессор будет выполнять инструкции NOP, пока не дойдет до какого-то другого кода.

Пример использования

; Не делать ничего
NOP

HLT

Инструкция HLT останавливает выполнение процессора.

После выполнения этой инструкции процессор входит в состояние, в котором выполнение кода прекращается до получения внешнего прерывания. Если внешнее прерывание получено, то процессор считывает с линий данных один байт инструкции (обычно это одна из RST-инструкций) и выполняет её.

Пример использования

; Остановить выполнение навсегда
DI
HLT

IN/OUT

Инструкции IN d8 и OUT d8 используются для того, чтобы передавать данные во внешний порт или принимать данные из внешнего порта. Какой именно смысл имеют эти порты, зависит от конкретного оборудования вокруг процессора. Для систем, в которых есть системные вызовы (вроде СМ-1800), чаще всего следует не использовать эти инструкции самому, а вместо этого вызывать системные подпрограммы для выполнения таких задач.

На аппаратном уровне можно считать, что у Intel 8080 на самом деле 17-битная адресная шина, где верхняя линия – это IORQ, которая равна 0 при обычной работе с памятью и 1 при выполнении IN и OUT.

При выполнении OUT, нижние 8 бит адресной шины устанавливаются в значение, переданное как аргумент инструкции. После этого процессор выдает значение A на линию данных, и внешнее оборудование может прочитать его оттуда.

При выполнении IN, нижние 8 бит устанавливаются в значение аргумента инструкции. После этого внешнее оборудование должно передать значение в процессор на линию данных, которое процессор принимает и записывает в регистр A.

Пример использования

; Передать значение 0x55 в порт 0xC3
MVI A, 0x55
OUT 0xC3

; Читать значение из порта 0xA2
IN 0xA2

DI/EI

Пара инструкций DI и EI используется для управления прерываниями. DI (disable interrupts) выключает прерывания, а EI (enable interrupts) включает их.

Прерывания – это способ позволить оборудованию вокруг процессора останавливать выполнение основной программы и вместо этого делать некое действие в ответ на внешнее событие.

Прерывания работают следующим образом: если внешнее оборудование хочет вызвать прерывание, то подается сигнал на линию прерываний. Когда процессор завершает текущую инструкцию, он подтверждает, что получил прерывание. После этого внешнее оборудование должно подать на линию данных инструкцию из одного байта – чаще всего это одна из RST-инструкций.

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

Пример использования

; Подождем до получения следующего прерывания
EI
HLT ; zzz...

; Если мы здесь, то мы уже получили и обработали прерывание
; Снова включим получение прерываний 
EI

⤵ Переходы и вызовы

Эти инструкции служат для изменения потока выполнения программы. Используя эти инструкции, можно реализовать циклы, процедуры и функции, условные блоки (if/else) и другие похожие конструкции высокоуровневых языков программирования.

Условные инструкции

У инструкций перехода есть три вида: JMP, CALL и RET. Каждый из этих видов имеет 9 различных вариантов: один выполняет свое действие всегда, а остальные – в зависимости от текущего состояния флагов процессора. Все инструкции одного и того же вида имеют одинаковое поведение, если они выполняют переход, поэтому их действие описано один раз для каждого вида.

`JMP`	`CALL`	`RET`	переходит безусловно
`JZ`	`CZ`	`RZ`	переходит, если установлен флаг Z (результат равен 0)
`JNZ`	`CNZ`	`RNZ`	переходит, если не установлен флаг Z (результат не равен 0)
`JC`	`CC`	`RC`	переходит, если установлен флаг CY (есть переполнение)
`JNC`	`CNC`	`RNC`	переходит, если не установлен флаг CY (нет переполнения)
`JPE`	`CPE`	`RPE`	переходит, если установлен флаг P (количество единиц в результате – четное)
`JPO`	`CPO`	`RPO`	переходит, если не установлен флаг P (количество единиц в результате – нечетное)
`JM`	`CM`	`RM`	переходит, если установлен флаг S (результат меньше 0)
`JP`	`CP`	`RP`	переходит, если не установлен флаг S (результат больше или равен 0)

JMP

Эта инструкция имеет условные варианты.

Инструкция JMP a16 принимает аргумент в виде адреса. Если выполняется переход, то следующая инструкция, которую процессор начнет выполнять, будет находиться по этому адресу.

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

делать циклы
реализовывать условные операторы
пропускать куски памяти, которые не являются кодом

Пример использования

; Перейти к адресу 0x1234
JMP 0x1234
; (или, если написать байты раздельно)
JMP 0x34 0x12

Выполним какое-то действие 10 раз:

; Сначала инициализируем счетчик: пусть в регистре A будет значение 10
MVI A, 10
; Метка начала цикла
loop:
    ; Выполним какое-то действие
    NOP ; ...
    NOP ; ...
    ; Сделали действие!
    ; Теперь вычтем единицу из счетчика
    DCR A
    ; Если счетчик еще не равен нулю, перейдем к началу цикла
    JNZ loop
; Если мы здесь, то мы не сделали переход в начало, значит цикл завершился
NOP ; ...

Получим значение из порта, и если оно имеет четное количество единиц, то выведем другое значение:

; Сначала считываем значение
IN 0xD0
; Проверяем его (устанавливаем флаги)
CPI 0x00
; Если оно не четное, то нужно пропустить следующий кусок кода
JPO not_even_parity
    ; Если мы здесь, то значение имеет четное количество единиц, и мы делаем вывод
    MVI A, 0x20
    OUT 0xD0
not_even_parity:
; Если мы здесь, значит мы либо выполнили переход и пропустили вывод, либо только что сделали вывод
NOP ; ...

Добавим строку внутри кода:

NOP ; ...
NOP ; ...
; Сейчас я хочу вывести какую-то строку на экран,
; но я хочу записать эту строку прямо здесь в памяти.
; Чтобы процессор не начал выполнять эту строку как код, мы должны пропустить ее.
JMP skip_string  ; перейдем на метку, которая после конца строки
string:  ; эта метка будет обозначать начало строки
  DB "HELLO WORLD!\0"  ; запишем строку в память
skip_string:  ; эта метка указывает на инструкции после конца строки
LXI BC, string  ; передадим адрес строки в регистр BC
CALL 0x0043     ; вызовем функцию вывода строки

CALL

Эта инструкция имеет условные варианты.

Инструкция CALL a16, как и инструкция JMP a16, принимает в качестве аргумента адрес, к которому нужно перейти. Однако при вызове CALL, помимо перехода, дополнительно значение регистра PC записывается в стек. Это нужно, чтобы будущая инструкция RET могла вернуться в этот код.

Эта инструкция используется для того, чтобы вызывать подпрограммы – куски кода, которые нужно использовать несколько раз. Когда выполняется CALL, процессор запоминает на стек, как вернуться к основной программе, и затем начинает выполнять подпрограмму. Когда подпрограмма завершается, она использует инструкцию RET, и процессор достает этот запомненный адрес из стека и переходит к нему, возвращаясь в основную программу.

Инструкция CALL только сохраняет адрес возврата в стеке – она не изменяет регистры или флаги. Это означает, что текущие значения регистров доступны подпрограмме, и являются основным способом передачи данных в подпрограмму.

Пример использования

; Подпрограмма, которая умножает значение в регистре A на 10
times_10:
    ; мы будем использовать регистр B как временное хранилище
    ; запишем его текущее значение на стек
    PUSH BC
    ; A = x
    ADD A    ; A = x + x = 2*x
    MOV B,A  ; B = A = 2*x
    ADD A    ; A = 2*x + 2*x = 4*x
    ADD A    ; A = 4*x + 4*x = 8*x
    ADD B    ; A = 8*x + 2*x = 10*x
    ; вернем значение из стека в регистр B
    POP BC
    ; возвращаемся в основную программу
    RET

; Установим значение регистра A
MVI A, 3
; Вызовем подпрограмму
CALL times_10
; Теперь значение регистра A будет равно 30

RET

Эта инструкция имеет условные варианты.

Инструкция RET считывает значение из стека и переходит к адресу, записанному в этом значении.

Используя эту инструкцию, можно создавать подпрограммы – куски кода, которые можно использовать несколько раз из разных мест основной программы.

Если подпрограмма использует инструкции управления стеком, то следует быть аккуратным при написании кода, чтобы к моменту вызова RET стек был на том же уровне, что и в начале подпрограммы. Это из-за того, что при вызове RET, процессор достает значение из стека и переходит к адресу, записанному в этом значении, и если программа выполнила PUSH, который не был взят обратно с POP, то при попытке вернуться в основную программу, процессор вместо этого не вернется к ожидаемому адресу.

Пример использования

; Подпрограмма, которая умножает значение в регистре A на 10
times_10:
    ; мы будем использовать регистр B как временное хранилище
    ; запишем его текущее значение на стек
    PUSH BC
    ; A = x
    ADD A    ; A = x + x = 2*x
    MOV B,A  ; B = A = 2*x
    ADD A    ; A = 2*x + 2*x = 4*x
    ADD A    ; A = 4*x + 4*x = 8*x
    ADD B    ; A = 8*x + 2*x = 10*x
    ; вернем значение из стека в регистр B
    POP BC
    ; возвращаемся в основную программу
    RET

; Установим значение регистра A
MVI A, 3
; Вызовем подпрограмму
CALL times_10
; Теперь значение регистра A будет равно 30

Пример проблемы при вызове RET с использованием стека:

; Подпрограмма, которая делает что-то полезное
subprogram:
  NOP  ; ...
  NOP  ; ...
  ; ... Во время работы подпрограммы мы положили значение на стек
  MVI H, 0x40
  MVI L, 0x00
  PUSH HL
  NOP  ; ...
  NOP  ; ...
  ; !!! Мы забыли сделать POP !!!
  RET  ; Этот RET считает значение от PUSH и перейдет к адресу 0x4000 !!


; Если попробовать использовать эту подпрограмму в основной программе...
NOP   ; ...
NOP   ; ...
CALL subprogram
NOP   ; <-- Этот код не будет выполнен -- мы не вернемся сюда

RST

Инструкции RST 0, RST 1 … RST 7 выполняют то же самое, что CALL, к адресу 0x0000 + n*8, где n от 0 до 7. Это означает, что при вызове RST 0, процессор перейдет к адресу 0x0000, при вызове RST 1 процессор перейдет к адресу 0x0008, при вызове RST 2 процессор перейдет к адресу 0x0010 и т.д.

Эти инструкции полезны больше всего для работы с внешними прерываниями. Когда происходит прерывание, процессор считывает и выполняет одну инструкцию с шины данных, прежде чем продолжить работать как обычно. Каждая из инструкций RST занимает один байт, поэтому если в этот момент на шине данных выставить один из восьми опкодов RST, то процессор запомнит свое последнее положение в коде на стек. и выполнит код для обработки прерывания. Процедура прерывания затем может использовать RET, чтобы вернуться к основному коду и продолжить работу как обычно.

Эти опкоды также являются обычными инструкциями, поэтому можно использовать их в своем коде. Например, если вызвать инструкцию RST 0, то процессор перейдет к адресу 0x0000, как будто он был толькол что перезагружен с помощью линии RESET.

Пример использования

; Бесконечно принимаем значение из порта
; Если это значение стало равно 0, перезагружаем процессор
loop:
  IN 0x80   ; считываем значение
  CPI 0x00  ; сравниваем с 0
  JNZ loop  ; если не равно, продолжаем цикл
; теперь значение равно 0
RST 0     ; перезагружаем процессор

📩 Загрузка, сохранение и перемещение, 8-бит

Эти инструкции используются для перемещения информации, один байт за раз.

MOV

Эта инструкция копирует значение из источника в назначение. Она является одной из самых часто используемых во всем наборе инструкций.

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

Первый аргумент – это назначение, а второй аргумент – это источник. Можно читать это как операцию присваивания: MOV X,Y значит X = Y.

Аргументы – это один из следующих символов: A, B, C, D, E, H, L, M. Первые семь из этих – это названия регистров процессора, и операции между ними осуществляются полностью внутри процессора. Аргумент M – особенный: он обозначает ячейку памяти, адрес которой записан в паре регистров HL.

Операции вида MOV X,X копируют значение из какого-то регистра в сам этот регистр, тем самым не меняя его значение. Таким образом, они являются альтернативой NOP. В определенных задачах, когда важно, сколько времени занимает выполнение инструкций, операции вида MOV X,X действительно использовались как слегка более длительный NOP.

Среди набора инструкций отсутствует инструкция MOV M,M – ее место занимает инструкция HLT.

Пример использования

; Скопировать значение из регистра B в регистр A
MOV A,B

; Скопировать значение из памяти по адресу `0x1234` в регистр C
LXI H, 0x1234
MOV C, M

; Скопировать значение из памяти `0x1234` в `0x5678`, через регистр D
LXI H, 0x1234
MOV D, M  ; теперь D содержит значение из памяти 0x1234
LXI H, 0x5678
MOV M, D  ; теперь память 0x5678 содержит значение в D, которое было скопировано из памяти 0x1234

MVI

Инструкция MVI загружает в регистр значение, которое передается как аргумент.

Регистр задается таким же образом, как и в операции MOV – один из A, B, C, D, E, H, L, M.

Пример использования

; Загрузить значение 0x12 в регистр A
MVI A, 0x12

; Загрузить значение 0x34 в память по адресу 0xABCD
LXI H, 0xABCD
MVI M, 0x34

LDAX/STAX

Эта инструкция перемещает значение между регистром A и памятью по адресу в паре регистров.

Принимается аргумент – один символ, B или D – который обозначает, что нужно использовать адрес в регистрах BC или DE, соответственно. Инструкция LDAX считывает значение из памяти в регистр A, а STAX – наоборот, из регистра в память.

Пример использования

; Считать значение из памяти по адресу 0x1234 в регистр A
LXI B, 0x1234
LDAX B

; Переместить значение из памяти по адресу 0x1234 в память по адресу 0x5678 через регистр A
LXI B, 0x1234
LXI D, 0x5678
LDAX B
STAX D

LDA/STA

Эта инструкция делает то же самое, что и LDAX/STAX – загружает или сохраняет значение между памятью и регистром A. В отличии от LDAX/STAX, эта инструкция принимает аргумент – адрес, относительно которого следует произвести операцию.

Пример использования

; Считать значение из памяти по адресу 0x1234 в регистр A
LDA 0x1234

; Переместить значение из памяти по адресу 0x1234 в память по адресу 0x5678 через регистр A
LDA 0x1234
STA 0x5678

📥 Загрузка, сохранение и перемещение, 16-бит

Эти инструкции используются для перемещения пар байтов.

LXI

Эта инструкция загружает значение аргумента в пару регистров.

Принимает два аргумента: название пары регистров (B для BC, D для DE, H для HL или SP для регистра-указателя на стек), и 16-битное значение. Загружает значение в указанную пару регистров.

Пример использования

; Загрузить значение 0x1234 в пару регистров BC
LXI B, 0x1234

; Инициализировать стек по адресу 0xff00
LXI SP, 0xff00

LHLD/SHLD

Эти две инструкции используются для перемещения значения между парой регистров HL и памятью.

Обе инструкции принимают аргумент – адрес a16. Инструкция LHLD считывает значение по адресу a16 в регистр L, а значение по адресу a16 + 1 в регистр H. Инструкция SHLD, наоборот, записывает значение L в a16, а H – в a16 + 1.

Пример использования


; Загрузить значение из адреса 0x4000 в HL
LHLD 0x4000

; Сохранить значение из HL в адрес 0x4000
SHLD 0x4000

; Сохранить значение 0xBEEF в адрес 0x1234 через HL
LXI H, 0xBEEF
SHLD 0x1234

PUSH/POP

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

Стек – это область памяти, которую можно использовать для хранения временных значений. Например, там хранятся адреса возврата для подпрограмм, вызываемых с помощью CALL.

Обе инструкции принимают аргумент – один из B, D, H или PSW. Это – название пары регистров, которые будут записаны в стек или извлечены из него.

Поскольку адреса для возвращения из подпрограммы также находятся в стеке, следует быть осторожным при использовании стека в своих программах. К тому моменту, как вызывается RET, следует убедиться, что все операции PUSH имеют соответствующие им операции POP (можно представлять PUSH и POP как скобки вокруг блоков кода – тогда это правило значит, что последовательность скобок должна быть правильной). Это нужно потому, что, если на верху стека лежит что-то кроме адреса возврата, то при выполнении RET процессор перейдет не обратно в основную программу, а в неизвестное место в памяти.

Инструкция PUSH делает следующее:

Записывает старшие 8 битов значения пары регистров в адрес SP - 1.
Записывает младшие 8 битов значения пары регистров в адрес SP - 2.
Уменьшает значение SP на 2.

Инструкция POP делает следующее:

Извлекает младшие 8 битов значения пары регистров из адреса SP.
Извлекает старшие 8 битов значения пары регистров из адреса SP + 1.
Увеличивает значение SP на 2.

Аргумент B значит, что старшим байтом считается регистр B, а младшим – C. Аргумент D значит, что старшим байтом считается регистр D, а младшим – E. Аргумент H значит, что старшим байтом считается регистр H, а младшим – L.

Аргумент PSW (Program Status Word) особенный – для него старшим байтом считается значение регистра A, а младшим – особый байт, содержащий все флаги процессора:

Бит	7	6	5	4	3	2	1	0
Значение	`S`	`Z`	всегда 0	`AC`	всегда 0	`P`	всегда 1	`CY`

При PUSH PSW биты 5, 3 и 1 младшего байта, который находится на стеке, имеют значения 0, 0 и 1 соответственно. При POP PSW биты 5, 3 и 1 игнорируются.

Пример использования

; Записать в стек значение всех регистров
PUSH B
PUSH D
PUSH H
PUSH PSW

; Выполнить что-то...
NOP
NOP
; ...сохраняем результаты работы в память...
NOP

; Теперь возвращаем процессор в исходное состояние всех регистров
; (результаты работы были записаны в память)

POP PSW  ; инструкции POP идут в обратном порядке от PUSH
POP H
POP D
POP B

SPHL

Эта инструкция загружает в регистр SP значение из пары регистров H и L. Значение в HL не изменяется.

Пример использования

; Инициализировать стек по адресу `0xfff0`
LXI H, 0xff
LXI L, 0xf0
SPHL  ; теперь SP = HL = 0xfff0

XCHG

Эта инструкция меняет местами значения в паре регистров DE и HL.

Пример использования

MVI D, 0xDE
MVI E, 0xAD
MVI H, 0xBE
MVI L, 0xEF
; Теперь DE = 0xDEAD, HL = 0xBEEF
XCHG
; Теперь DE = 0xBEEF, HL = 0xDEAD

XTHL

Эта инструкция меняет местами значение в паре регистров HL и значение на верхушке стека.

Более точно, сначала меняется местами значение регистра L и ячейки памяти по адресу SP, а затем меняется местами значение регистра H и ячейки памяти по адресу SP+1.

Пример использования

LXI B, 0xABCD
PUSH B
LXI H, 0x1234
; Теперь на верхушке стека лежит значение 0xABCD, а HL=0x1234
XTHL
; Теперь на верхушке стека лежит значение 0x1234, а HL=0xABCD

🧮 Арифметические и логические операции, 8-бит

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Эти инструкции выполняют преобразования над 8-битными значениями. Каждая из этих инструкций принимает значение из регистра A, преобразует его и записывает в регистр A.

Информация про флаги

У процессора есть 5 флагов, которые обозначают результаты выполнения арифметических и логических операций. Эти флаги называются S, Z, AC, P, CY.

Для флагов, слово “установить” значит “сделать равным 1”, а “сбросить” – “сделать равным 0”.

Z (Zero) – устанавливается, если результатом операции является 0.
S (Sign) – устанавливается, если результат операции отрицательный (используя дополнительный код, то есть если старший бит результата равен 1).
P (Parity) – устанавливается, если двоичное представление результата операции имеет нечетное число единиц.
CY (Carry) – устанавливается, если при выполнении операции произошло переполнение.
AC (Auxiliary Carry) – устанавливается, если при выполнении операции произошло переполнение из бита 3 (используется только для инструкции DAA).

Флаг P всегда обозначает четность результата. Флаг Z всегда устанавливается, если результат операции равен 0. Флаг S всегда обозначает значение старшего бита. Значение флагов CY и AC определяется в зависимости от инструкции.

Инструкции с immediate-значением

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Некоторые инструкции, которые принимают как аргумент название регистра со значением, имеют альтернативный вариант. В этом альтернативном варианте они принимают как аргумент само это значение. Значение, написанное непосредственно в коде, называется immediate.

Поведение этих инструкций идентично поведению обычных вариантов, в том числе работа с флагами. Для информации по этим вариантам смотри документацию обычного варианта инструкции.

Обычная инструкция	Immediate-вариант
`ADD`	`ADI`
`ADC`	`ACI`
`SUB`	`SUI`
`SBB`	`SBI`
`CMP`	`CUI`
`ANA`	`ANI`
`XRA`	`XRI`
`ORA`	`ORI`
`CMP`	`CPI`

Пример использования

; Пример инструкции ADD
MVI A, 0x01
MVI B, 0x02
ADD B
; Теперь A = 0x03

; Пример замены этой инструкции на immediate-вариант
MVI A, 0x01
ADI 0x02
; Теперь A = 0x03

ADD

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Флаги Z, S и P обновляются как обычно.

Эта инструкция добавляет к значению в аккумуляторе значение из аргумента.

Если результат оказывается больше 255, то происходит переполнение. Из итогового результата вычитается 256 (то есть, если результат был 257, то в A будет записано 1, и т. д.), а флаг CY будет установлен.

Если при сложении двух значений в столбик получается перенос в бит 4 из бита 3, то устанавливается флаг AC. Пример:

Номер бита	7	6	5	4	3	2	1	0
`0x2E`	0	0	1	0	1	1	1	0
`+ 0x74`	0	1	1	1	0	1	0	0
`= 0xA2`	1	0	1	0	0	0	1	0
	↓			↓
	`CY=0`			`AC=1`

ADC

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Эта инструкция выполняет то же самое, что и ADD, только к результату ещё добавляется значение флага CY. Эта инструкция полезна, когда производится сложение над числом, занимающим несколько байтов.

SUB

Флаги Z, S и P обновляются как обычно.

Эта инструкция вычитает из значения в аккумуляторе значение аргумента, согласно правилам дополнительного кода

Если из старшего бита нет переноса – то есть если было заимствование – то флаг CY устанавливается, иначе сбрасывается. Это противоположное поведение от операции сложения, где CY сбрасывается при отсутствии переполнения.

SBB

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Сначала, значение флага CY внутренне добавляется к значению аргумента. Затем результат этого вычитается из аккумулятора, как с SUB.

ANA

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Выполняет побитовое И между значением аккумулятора и значением аргумента. Для каждого из 8 битов, если значение бита в аккумуляторе и значение бита в аргументе равно 1, то в ответе бит устанавливается в 1, иначе 0.

Флаг CY сбрасывается. Флаги Z, S и P обновляются как обычно.

XRA

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Выполняет побитовое исключительное-ИЛИ между значением аккумулятора и значением аргумента. Для каждого из 8 битов, если значение бита в аккумуляторе и значение бита в аргументе различается, то в ответе бит устанавливается в 1, иначе 0.

Флаги CY и AC сбрасывается. Флаги Z, S и P обновляются как обычно.

ORA

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Выполняет побитовое ИЛИ между значением аккумулятора и значением аргумента. Для каждого из 8 битов, если либо значение бита в аккумуляторе, либо значение бита в аргументе равно 1, то в ответе бит устанавливается в 1, иначе 0.

Флаги CY и AC сбрасывается. Флаги Z, S и P обновляются как обычно.

CMP

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Эта инструкция выполняет сравнение значения аккумулятора с значением аргумента.

Внутренне, из значения регистра A вычитается значение аргумента, результат игнорируется (оба регистра остаются неизменными), а флаги устанавливаются в соответствии с результатом вычитания.

В частности, Z будет установлен, если два значения равны, и сброшен, если они не равны. Поскольку выполняется вычитание, флаг CY будет установлен, если значение аргумента больше значения аккумулятора, и сброшен иначе.

Флаги Z, S и P обновляются как обычно (относительно результата внутреннего вычитания).

INR/DCR

Эти две инструкции изменяют значение указываемого регистра на 1. Операция INR X эквивалентна ADI X, 1, а DCR X эквивалентна SUI X, 1. Поэтому, она также изменяет флаги Z, S, P и AC таким же образом, как и соответствующие инструкции сложения и вычитания.

RLC/RRC/RAL/RAR

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Эти четыре инструкции служат для побитового сдвига аккумулятора. RLC вращает регистр влево ←, RRC – вправо →, а RAL и RAR вращают регистр через флаг переноса CY. Важно заметить, это противоположно интуиции – инструкции с буквой C в названии не используют флаг CY для осуществления переноса, а RLC и RRC, наоборот, используют.

В микроконтроллерах, современных Intel 8080, по умолчанию осуществлялся N+1-перенос, и по умолчанию сдвиги производились через бит переноса. Можно запомнить операции RLC и RRC как Rotate Left/Right and Copy. Более детальное обсуждение можно увидеть в вопросе на Retrocomputing Stack Exchange.

Побитовый сдвиг – это операция, при которой биты регистра перемещаются между позициями:

Состояние регистра	7	6	5	4	3	0
Начальное значение	1	1	1	1	0	0
После сдвига вправо →	0	1	1	1	1	0
После сдвига влево ←	1	1	1	0	0	1

В этой таблице приведен пример сдвига, при котором тот бит, который оказался выдвинут из байта, оказывается на противоположном конце байта – например, при сдвиге вправо → бит 0 перешел в бит 7, а при сдвиге влево ← бит 7 перешел в бит 0. Так работают операции RLC и RRC. При выполнении этих операций бит, который оказался выдвинут, также записывается в флаг переноса CY.

При операции RAL/RAR также осуществляется сдвиг, но на этот раз по 9-битному значению, составленному из 8-битного аккумулятора и бита переноса CY. При RAL сдвиг происходит влево ←, и флаг CY дописывается слева ← от аккумулятора.

Состояние регистров	`CY`	7	6	5	4	3	2	1	0
До `RAL`	0	1	1	1	1	0	0	0	0
После `RAL`	1	1	1	1	0	0	0	0	0
После двух `RAL`	1	1	1	0	0	0	0	0	1
После трех `RAL`	1	1	0	0	0	0	0	1	1
После четырех `RAL`	1	0	0	0	0	0	1	1	1
После пяти `RAL`	0	0	0	0	0	1	1	1	1
После шести `RAL`	0	0	0	0	1	1	1	1	0

При RAR сдвиг происходит вправо →, и флаг CY дописывается справа → от аккумулятора.

Состояние регистров	7	6	5	4	3	2	1	0	`CY`
До `RAR`	1	1	0	0	0	0	1	1	0
После `RAR`	0	1	1	0	0	0	0	1	1
После двух `RAR`	1	0	1	1	0	0	0	0	1
После трех `RAR`	1	1	0	1	1	0	0	0	0
После четырех `RAR`	0	1	1	0	1	1	0	0	0
После пяти `RAR`	0	0	1	1	0	1	1	0	0
После шести `RAR`	0	0	0	1	1	0	1	1	0

DAA

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Эта инструкция изменяет значение в аккумуляторе, используя значения в флагах CY и AC, чтобы преобразовать результат операции ADD или SUB в значение в двоично-десятичном формате.

Одно 8-битное значение может представлять две десятичных цифры, если старшие и младшие 4 бита каждый не превышают 9. Между несколькими байтами, содержащими так закодированные значения, можно выполнять арифметику, используя обычные 8-битные арифметические операции – нужно лишь проверять, что после каждой операции сохраняется свойство, что каждые из 4-битных значений не превышают 9. Операция DAA (Decimal Adjust Accumulator) осуществляет эту проверку и изменение по следующим правилам:

Если младшие 4 бита имеют значение больше 9, или если флаг AC установлен, то значение аккумулятора увеличивается на 6, иначе увеличение не происходит. Если произошел перенос из младших 4 битов, устанавливается флаг AC.
Если после шага 1 старшие 4 бита аккумулятора имеют значение больше 9, или если установлен флаг CY, то значение старших 4 битов увеличивается на 6, иначе увеличение не происходит. Если произошел перенос из старших 4 битов, устанавливается флаг CY.

Флаги Z, S и P обновляются как обычно.

Псевдокод для операции DAA (списано из кода эмулятора Intel 8080):

procedure DAA is
  NCY := RegF.CY
  correction := 0x00
  LSB := RegA & 0x0F
  MSB := RegA >> 4

  if RegF.AC or LSB > 9 then
    correction := 0x06
  end if

  if RegF.CY or MSB > 9 or (MSB >= 9 and LSB >= 9) then
    correction := (correction | 0x60)
    NCY := 1
  end if

  call ADI(correction)
  RegF.CY := NCY
end procedure

STC/CMC

⬆ Вернуться к арифметико-логическим инструкциям, 8-бит

Эти две инструкции используются для управления флагом CY. Инструкция STC устанавливает флаг CY в состояние 1, а инструкция CMC изменяет его значение на противоположное.

Пример использования

STC
; Теперь `CY=1`
JNC 0x4000  ; переход не будет осуществлен, потому что `CY ≠ 0`

CMC
; Теперь `CY=0`
JNC 0x4000  ; переход будет осуществлен, потому что `CY = 0`

📐 Арифметико-логические инструкции, 16-бит

⬆ Вернуться к арифметико-логическим инструкциям, 16-бит

Эти инструкции используются для выполнения арифметических операций над 16-битными значениями.

INX/DCX

Эти две инструкции позволяют инкрементировать или декрементировать (то есть, изменять на единицу в обе стороны) значение пары регистров BC (через аргумент B), DE (D), HL (H) или регистра – указателя на верхушку стека SP.

Эти операции не изменяют значение флагов и тихо переполняются через 16-битные значения. Например, если в H есть значение 0x7f, а в L есть значение 0xff, то после выполнения INX H, в H будет значение 0x80, а в L будет значение 0x00. Аналогично, если сначала B равен 0xff и C равен 0xff, то после выполнения INX B, в B будет 0x00, а в C будет 0x00.

Эти инструкции больше всего полезны для манипуляции адресами памяти. Например, комбинированный регистр HL используется как указатель в память для записи или чтения, и используя операции INX и DCX, можно перемещать этот указатель между близкими адресами.

Пример использования

; В бесконечном цикле, двигать указатель вперед по памяти,
; и для каждой ячейки увеличить их значение на 5.
; (Эта программа перезапишет всю память, в том числе
; свой собственный код, поэтому цикл не будет выполняться бесконечно.)

LXI H, 0x0000 ; перейти к началу памяти
loop:     ; метка на начало цикла
MOV A, M  ; загрузить значение из памяти
ADI 5     ; прибавить 5 к аккумулятору
MOV M, A  ; записать значение в память
INX H     ; перейти к следующей ячейке памяти
JMP loop  ; перейти к началу цикла

DAD

⬆ Вернуться к арифметико-логическим инструкциям, 16-бит

Эта инструкция выполняет сложение между 16-битными значениями. К значению в регистрах HL добавляется значение из одного из регистров BC, DE, HL, SP. Если результат оказывается больше максимального 16-битного значения, то устанавливается флаг CY.

Пример использования

LXI H, 0x7f00
LXI B, 0x0100
; Теперь HL=0x7f00, BC=0x0123
DAD B
; Теперь HL=0x8023, CY=0

LXI H, 0xf000
LXI D, 0x1100
; Теперь HL=0xf000, DE=0x1100
DAD D
; Теперь HL=0x0100, CY=1

🤬 Неопределенные инструкции