FORTH-ассемблер

Эта штука относится к вещам, о которых говорят, либо: "Давно все уже сделано",- это, если никто не требует показать, либо: "И делать не стоит",- это, если просят. И такой подход действительно имеет глубокие корни в мышлении микро-фортеров.
***

Попробуем разобраться. Каково место FORTH в разработке ПО?
Тут опять повторю старый кусок - ТЕМА #30, АБЗАЦ #578:

0) Программирование нулевого уровня - ручной ввод команд одна за другой.
1) Командные файлы (скрипты) - несколько команд "упакованных в одну", возможно даже с какой-то примитивной логикой "если ошибка, то...".
2) "Программы с вводом".
3) FORTH.
4) BASIC.

Однако, как ни назови, несомненно одно: нам придется залезть внутрь нашей исходной машины. И начать писать не на исходном языке команд, а в машинных кодах И большая часть нашего BASIC-интерпретатора будет в этих кодах и написана. В случае же использования FORTH-метода "отскок в коды" будет совсем невелик - всего десяток основополагающих слов. Но, все равно, будет.

Т.е. FORTH-ассемблер - это тот самый "отскок в коды" и состоит он из трех кусков:

1) ПСЕВДОСЛОВА. Код, который нам придется засунуть внутрь FORTH, чтобы тот заработал. Очевидно, писать его придется еще не в FORTH (а, например, в debug.com). Это очень важный кусок кода, который самому FORTH почти "не виден". О нем поговорим (точнее, послушаем Мура, когда будем обсуждать писание FORTH-системы "с нуля"). Псевдословами их назовем, т.к. скоре всего они не будут оформлены в системе, как настоящие слова.

2) ВНУТРЕННИЕ КОДОВЫЕ СЛОВА. Код, который может понадобиться FORTH для более удобного объединения "команд в скрипты": всякие там расширенные средства работы со СТЕКОМ, СЛОВАРЕМ, ЗНАЧЕНИЕМ и ПОТОКОМ.

3) ВНЕШНИЕ КОДОВЫЕ СЛОВА. Код для написания новых "команд для скриптов". Что понадобится пользователю, мы не знаем, может, телескопом управлять, а, может, с распределенными базами данных работать... Значит, надо ему оставить лазейку для написания "чего угодно". (Кстати, эта возможность изначально была во всякого рода BASIC-ах и даже FoxBase+-ах и не является следствием особенности FORTH).

Прежде чем рассматривать отличие ВНУТРЕННИХ от ВНЕШНИХ, посмотрим, как их можно организовать.

CHARLES H.MOORE PROGRAMMING A PROBLEM-ORIENTED-LANGUAGE
4. PROGRAMS THAT GROW / ПРОГРАММЫ, КОТОРЫЕ РАСТУТ
4.5. CODE ENTRIES / КОДОВЫЕ СТАТЬИ

ТЕМА #3, АБЗАЦ #1274

Таким образом, мы видим, что FORTH-ассемблер состоит всего из двух деталей - "запятой" и некоего способа передавать управление на то, что при помощи этой "запятой" нафигачили.

Т.е. все дальнейшее совершенствование FORTH-ассемблеров сводится к приданию "запятой" большьшей мощности и удобства. Научить ее записывать не только откомпилированные вручную машинные коды, но и красивые слова на высокоуровневом макро-языке.

Тут, как раз всплывает различие между ВНУТРЕННИМИ и ВНЕШНИМИ КОДОВЫМИ СЛОВАМИ. Для программирования первых достаточно очень ограниченного набора машинных команд (как и для написания обычного компилятора). Что порождает у микрофортеров желание создать FORTH-ассеблер для этого набора, придумав десяток красивых имен для "нужного" и забыв про "ненужное". Настоящие программисты сказали бы, что они пытаются придумать набор макросов на все случаи жизни.

Для ВНЕШНИХ КОДОВЫХ слов, конечно хочется иметь возможность использовать любые машинные коды без ограничений (даже, на всякий случай, те, использование которых обрушит FORTH- или Операционную Систему).

Эти два взаимоисключающих подхода и порождают не дают фортерам понять, что же такое FORTH-ассемблер? Не проще ли иметь два разных?

Но, позвольте, есть же универсальное решение!

С.Н.БАРАНОВ И Н.Р.НОЗДРУНОВ ЯЗЫК ФОРТ И ЕГО РЕАЛИЗАЦИИ

ТЕМА #120, АБЗАЦ #2033

и

ТЕМА #120, АБЗАЦ #2067 .

Т.е. практически все команды легко задаются в паре десятков строчек при помощи умных вариантов "запятой" - 1MI ... 5MI . Причем, весь их "ум" состоит в способности писать (компилировать) не одно число, а сразу несколько, в нужном формате. Написав эти "комиляторы" можно сразу, как предложено, добавлять ассемблеру уровень (т.е писать макросы).

Единственная сложность - надо знать эти самые машинные коды. Но, если мы честно написали свой FORTH со всеми его ПСЕВДОСЛОВАМИ, то, видимо, мы их знаем.

И, вот, на этой радостной ноте... "Пардон, кого вы дурите! Для моего процессора это не подходит!"
...

Действительно, для процессора, чуть более сложного, чем 8080 никаких 1MI... не хватит.
Попробуем посмотреть (16- и 32- разрядный FORTH-ассемблер для Intel-x86)...

\ Assembler. Compiler's words.
( Нотация: 1/2 - число байт
D/X - наличие бит dst/src/wrd
M/X - наличе довеска вместо поля reg)
: 1XX ( op->) <BUILDS C, DOES> ( ->) @ C, ;
: 1DX ( op->) <BUILDS C, DOES> ( dsw->) @ + C, ;
: 1XM ( op,reg->) <BUILDS C, C, DOES> ( ->reg) DUP 1+ @ C, C@ ;
: 1DM ( op,reg->) <BUILDS C, C, DOES> ( dsw->reg)
DUP 1+ @ ROT + C, C@ ;
: 1SR ( op->) <BUILDS C, DOES> ( sr->) @ SWAP 3 << + C, ;
: 2XX ( op->) <BUILDS , DOES> ( ->) @ , ;
: 2DX ( op->) <BUILDS , DOES> ( dst/src/wrd->)
@ SWAP 8 << + , ;
: 2XM ( op,reg->) <BUILDS C, , DOES> ( ->reg) DUP 1+ @ , C@ ;
: 2DM ( op,reg->) <BUILDS C, , DOES> ( dsw->reg)
DUP 1+ @ ROT 8 << + , C@ ;

(Кто не помнит, <BULDS ... DOES> это то же CREATE ... DOES> , только для FORTH с кривой реализацией CREATE).

Действительно, в x86 чуть более чем дофига разных команд. Деление на код и данные очень сильно зависит от формата команд. Есть коды, которые что-то втюхивают в поле данных, есть данные, дописывающиеся в конец кода...
1. Много префиксов (для модификации команд или тех команд, код которых не влезает в один байт). К счастью, префиксы простые, в их код не надо ничего вписывать (iXX).
2. Код большинства команд имеет в конце пару-другую бит, которые зависят от данных (iDX, 1SR).
3. За кодом команды следует байт (а в 32-битовом режиме, возможно и пара) управления данными. Если команда одноместная, сюда втюхивается непоместившийся в основные байты кусочек кода (iDM).
4. Размер, собственно, данных может быть самым разным, в зависимости от префиксов, кода и байтов управления данными.

\ Assembler. 8088. Команды без параметров.
\ 1XX-префиксы. ->
26 1XX ES: 2E 1XX CS: 36 1XX SS: 3E 1XX DS:
0F2 1XX REPNZ, 0F3 1XX REPZ,
\ 1XX-без-параметров. ->
27 1XX DAA, 2F 1XX DAS, 37 1XX AAA, 3F 1XX AAS,
90 1XX NOP, 98 1XX CBW, 99 1XX CWD, 9B 1XX WAIT,
9C 1XX PUSHF, 9D 1XX POPF, 9E 1XX SAHF, 9F 1XX LAHF,
0C3 1XX RET, 0CB 1XX RETFAR, 0CC 1XX INT3, 0CE 1XX INTO,
0CF 1XX IRET, 0D7 1XX XLAT, 0F0 1XX LOCK, 0F4 1XX HLT,
0F4 1XX HLT, 0F5 1XX CMC, 0F8 1XX CLC, 0F9 1XX STC,
0FA 1XX CLI, 0FB 1XX STI, 0FC 1XX CLD, 0FD 1XX STD,
\ 2XX-команды для коррекции результатов. ->
0AD4 2XX AAM, 0AD5 2XX AAD,

Это самое любимое место всех ассемблерописателей - просто коды, без какой-либо модификации.

\ Assembler. 8088. Простые команды.
\ 1XX-ассорти. ->
8D 1XX LEA, ( rw,m) 8F 1XX POPM, ( mw)
9A 1XX CALLFAR, ( cd) 0C2 1XX RETD, ( dw)
0C4 1XX LES, ( rw,ed) 0C5 1XX LDS, ( rw,ed)
0CA 1XX RETFARD, ( dw) 0CD 1XX INT, ( db)
0E0 1XX LOOPNE, ( cb) 0E1 1XX LOOPE, ( cb)
0E2 1XX LOOP, ( cb) 0E3 1XX JCXZ, ( cb)
0E8 1XX CALL, ( cw) 0E9 1XX JMP, ( cw)
0EA 1XX JMPFAR, ( cd) 0EB 1XX JMPSHORT, ( cb)
\ Безпараметровые команды для регистров. (s)reg->
06 1SR PUSHSR, 07 1SR POPSR, 40 1DX INCR, 48 1DX DECR,
50 1DX PUSHR, 58 1DX POPR, 90 1DX XCHGA,
\ 1DX-классические команды. dst/wrd-> r,e /кроме MOV/.
0 1DX ADD, 8 1DX OR, 10 1DX ADC, 18 1DX SBB,
20 1DX AND, 28 1DX SUB, 30 1DX XOR, 38 1DX CMP,

\ Assembler. 8088. Константные команды.
\ 1DX-операции с аккумулятором. wrd-> d
4 1DX ADDA, 0C 1DX ORA, 14 1DX ADCA, 1C 1DX SBBA,
24 1DX ANDA, 2C 1DX SUBA, 34 1DX XORA, 3C 1DX CMPA,
0A8 1DX TESTA,
\ 1DX-умножение на константу. src-> rw,ew,d
69 1DX IMULD,
\ 1DM-команды Immed. src/wrd->reg e,d
80 0 1DM ADDD, 80 1 1DM ORD, 80 2 1DM ADCD,
80 3 1DM SBBD, 80 4 1DM ANDD, 80 5 1DM SUBD,
80 6 1DM XORD, 80 7 1DM CMPD, 0F6 0 1DM TESTD, ( без src)
\ MOV Immed.
0B0 1DX MOVRDB, ( reg-> db) 0B8 1DX MOVRDW, ( reg-> dw)
0C6 0 1DM MOVED, ( wrd->000 e,d)
\ IN/OUT Immed. ( wrd-> db)
0E4 1DX IN, 0E6 1DX OUT,

\ Assembler. 8088. Основные 1DM-команды.
\ 1DM-сдвиги. wrd->reg e
0D0 0 1DM ROL1, 0D0 1 1DM ROR1, 0D0 2 1DM RCL1, 0D0 3 1DM RCR1,
0D0 4 1DM SHL1, 0D0 5 1DM SHR1, 0D0 7 1DM SAR1,
0D2 0 1DM ROLC, 0D2 1 1DM RORC, 0D2 2 1DM RCLC, 0D2 3 1DM RCRC,
0D2 4 1DM SHLC, 0D2 5 1DM SHRC, 0D2 7 1DM SARC,
\ 1DM-унарные команды. wrd->reg e
0F6 2 1DM NOT, 0F6 3 1DM NEG, 0F6 4 1DM MUL,
0F6 5 1DM IMUL, 0F6 6 1DM DIV, 0F6 7 1DM IDIV,
0FE 0 1DM INC, 0FE 1 1DM DEC,
0FF 6 1XM PUSHE, ( ->110 ew)
\ 1XM-переходы. ->reg e
0FF 2 1XM CALLEW, 0FF 3 1XM CALLED, 0FF 4 1XM JMPEW,
0FF 5 1XM JMPED,

\ Assembler. 8088. Прочие команды.
\ 1DX-остальные случаи MOV.
88 1DX MOV, ( dst/wrd-> r,e) 8C 1DX MOVSR, ( dst-> sr,ew)
0A0 1DX MOVA, ( dst/wrd-> m)
\ 1DX-симметричные. wrd-> r,e
84 1DX TEST, 86 1DX XCHG,
\ 1DX-строковые операции. wrd->
0A4 1DX MOVS, 0A6 1DX CMPS, 0AA 1DX STOS, 0AC 1DX LODS,
0AE 1DX SCAS,
\ 1DX-условные переходы. cond-> cb 10 70 1DX J,
\ IDX-работа с портом DX. wrd->
0EC 1DX INDX, 0EE 1DX OUTDX,

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

Нет, это не все, переходим к данным

Историческая бумажка - мой первый опыт ксерокопирования. Документация по TURBO-чему-то.



\ Assembler. 8088. Операнды-константы.
\ Регистры. ->reg
0 CONSTANT A 1 CONSTANT C 2 CONSTANT D 3 CONSTANT B
4 CONSTANT AH 5 CONSTANT CH 6 CONSTANT DH 7 CONSTANT BH
4 CONSTANT SP 5 CONSTANT BP 6 CONSTANT SI 7 CONSTANT DI
0 CONSTANT ES 1 CONSTANT CS 2 CONSTANT SS 3 CONSTANT DS
\ ->dst/src/wrd
0 CONSTANT /BO 1 CONSTANT /WO 2 CONSTANT /DB 2 CONSTANT /SO
3 CONSTANT /DW 3 CONSTANT /SW
\ ->cond
0 CONSTANT ?OV 1 CONSTANT ?NV 2 CONSTANT ?CY 3 CONSTANT ?NC
14 CONSTANT ?ZR 5 CONSTANT ?NZ 6 CONSTANT ?CY|ZR
7 CONSTANT ?NC&NZ 8 CONSTANT ?NG 9 CONSTANT ?PL 0A CONSTANT ?PE
0B CONSTANT ?PO 0C CONSTANT ?NG#OV 0D CONSTANT ?NG=0V
0E CONSTANT ?ZR|NG#OV 0F CONSTANT ?NZ&NG=OV

\ Assembler. 8088. Образование mod.reg.RM.
: /BA 8 OR ; : /WA 10 OR ; ( reg->mod.reg)
: [RG] ( reg1,reg2->) SWAP 3 << OR 0C0 OR C, ; ( 11.reg1.reg2,)
\ mod.reg-> mod.reg.RM, Нотация: B-bx P-bp S-si D-di
0 1SR [BS] 1 1SR [BD] 2 1SR [PS] 3 1SR [PD] 4 1SR [S]
5 1SR [D] 6 1SR [10] ( при mod=00) 6 1SR [P] 7 1SR [B]

Наученный горьким опытом, я не стал придумывать имена для комбинаций данных (все эти квадратные скобочки, запятые  и WORD PTR) и тупо вбиваю управляющие поля руками. Окупается. Где-то после третьей команде, я вспоминаю систему (т.е. систему адресации данных) и начинаю вбивать на автомате.

Конечно, наопределять всяких разных синтаксисов операндов на основе моих "кирпичиков" - не проблема.

И, да, до 32-разрядной адресации мы еще не дошли.

Новые процессоры - новые команды

\ Assembler. 80286. Команды защищенного режима.
\ 0F00 и 0F01 2XМ-команды ->reg ew
0F 0 2XM SLDT, 0F 1 2XM STR, 0F 2 2XM LLDT,
0F 3 2XM LTR, 0F 4 2XM VERR, 0F 5 2XM VERW,
10F 4 2XM SMSW, 10F 6 2XM LMSW,
\ 2XМ-команды ->reg ew /только память/
10F 0 2XM SGDT, 10F 1 2XM SIDT, 10F 0 2XM LGDT,
10F 3 2XM LIDT,
\ 0F 2XX-команды. ->
20F 2XX LAR, 30F 2XX LSL, ( rw,ew)
60F 2XX CLTS,
\ 1XX-проверка RPL. -> rw,ew
63 1XX ARPL,

\ Assembler. 80286. Прочие новые команды.
\ Работа со стеком.
60 1XX PUSHA, 61 1XX POPA,
80 1DX PUSHD, ( src-> d)
\ 1XX-проверка смещения. -> rw,ew /только память/
62 1XX BOUND,
\ 1DX-строковый ввод-вывод. w->
6C 1DX INS, 6E 1DX OUTS,
\ 1DM-сдвиги на константу. wrd->reg e,db
0C0 0 1DM ROLD, 0C0 1 1DM RORD, 0C0 2 1DM RCLD, 0C0 3 1DM RCRD,
0C0 4 1DM SHLD, 0C0 5 1DM SHRD, 0C0 7 1DM SARD,
\ 1XX-Pascal-процедуры. ->
0C8 1XX ENTER, ( dw,db)
0C9 1XX LEAVE,

В 80386:

\ Assembler. 80386. Новые команды.
\ Условные команды.
800F 2DX JNEAR, ( cond-> cw) 900F 0 2DM SET, ( cond->000 eb)
\ Проверка бита.
0A30F 2XX BT, 0AB0F 2XX BTS, ( -> rw,ew)
0B30F 2XX BTR, 0BB0F 2XX BTC,
0BA0F 4 2XM BTD, 0BA0F 5 2XM BTSD, ( ->reg ew,db)
0BA0F 6 2XM BTRD, 0BA0F 7 2XM BTCD,
0BC0F 2XX BSF, 0BD0F 2XX BSR, ( -> rw,ew)
\ 2XX-двойные-сдвиги. ->
0A40F 2XX SHLDD, 0AC0F 2XX SHRDD, ( rw,ew,db)
0A50F 2XX SHLDC, 0AD0F 2XX SHRDC, ( rw,ew)
\ 2DX-расширение-операнда. wrd-> r,e
0B60F 2DX MOVZX, 0BE0F 2DX MOVSX,
\ 2XX-нормальное умножение. -> rw,ew
0AF0F 2XX IMULX,

Наконец, 32-разрядная адресация





\ Assembler. 80386. Новые регистры и операнды.
\ 1XX-новые префиксы. ->
064 1XX FS: 65 1XX GS: 66 1XX OS| 67 1XX AS|
\ Новые регистры.
4 CONSTANT FS 5 CONSTANT GS
200F 2DX MOVCR, 210F 2DX MOVDR, 240F 2DX MOVTR, ( dst-> rd,ed)
0A00F 2XX PUSHFS, 0A30F 2XX POPFS, ( ->)
0A80F 2XX PUSHGS, 0A90F 2XX POPGS,
0B20F 2XX LSS, 0B40F 2XX LFS, 0B50F 2XX LGS, ( -> rw,ed)
\ 32-разрядная адресация.
( mod.reg-> mod.reg.RM) 4 1SR [SB] 5 1SR [20]
: /*2 8 OR ; : /*4 10 OR ; : /*8 18 OR ; ( ind->sc.ind)
: [IB] ( sc.ind,bas->) SWAP 3 << OR C, ; ( sc.ind.bas,)

К счастью, она проще 16-разрядной.

\ Assembler. 80486. P5. P6. Новые команды.
\ 80486. 2DX-перестановки.
0B00F 2DX CMPXCHG, ( wrd-> r,e) 0C80F 2DX BSAP, ( reg->)
0C00F 2DX XADD, ( wrd-> r,e)
\ 80486. Кэшевые.
80F 2XX INVD, 90F 2XX WBINVD, ( ->)
10F 7 2XM INVLPG, ( ->111 e)
\ P5.
0C70F 1 2XM CMPXCHG8B, ( ->reg eq) 0A20F 2XX CPUID, ( ->)
310F 2XX RDTSC, 320F 2XX RDMSR, ( ->)
300F 2XX WRMSR, 0AA0F 2XX RSM, ( ->)
\ P6.
400F 2DX CMOV, ( cond->) 330F 2XX RDPMC, ( ->)
0B0F 1DX UD2, ( ->)

\ Assembler. MMX. В основном, [+wrd]-> mmx,eq
2 CONSTANT /DO 3 CONSTANT /QO ( для +wrd, см. прим. ниже)
6E0F 2XX MOVXMD, 7E0F 2XX MOVMXD, 6F0F 2XX MOVXMQ,
7F0F 2XX MOVMXQ, 630F 2XX PACKSSDB, 6B0F 2XX PACKSSDW,
670F 2XX PACKUSWB, 0DB0F 2XX PAND, 0DF0F 2XX PANDN,
0F50F 2XX PMADDWD, 0E50F 2XX PMULHW, 0D50F 2XX PMULLW,
0EB0F 2XX POR, 0EF0F 2XX PXOR,
0FC0F 2DX PADD, 740F 2DX PCMPEQ, 640F 2DX PCMPGT, ( bwd)
0F80F 2DX PSUB, 680F 2DX PUNPCKH, 680F 2DX PUNPCKL, ( bwd)
0EC0F 2DX PADDS, 0DC0F 2DX PADDUS, 0E80F 2DX PSUBS, ( bw) 10 0D80F 2DX PSUBUS, ( bw)
0F00F 2DX PSLL, 0D00F 2DX PSRL, ( wdq)
0E00F 2DX PSRA, ( wd)
700F 6 2DM PSLLD, 700F 2 2DM PSRLD, ( wdq->reg eq,db)
700F 4 2DM PSRAWD, ( wd->reg eq,db)
770F 2XX EMMS, ( ->)

Думаю, принцип понятен...

Ах, да мы забыли про арифметический сопроцессор.

\ Assembler. 8087. Команды без параметров. ->
0EED9 2XX FLDZ, 0E8D9 2XX FLD1, 0EBD9 2XX FLDPI,
0E9D9 2XX FLDL2T, 0EAD9 2XX FLDL2E, 0ECD9 2XX FLDLG2,
0EDD9 2XX FLDLN2, ( Загрузки констант)
0F4D9 2XX FXTRACT, 0E1D9 2XX FABS, 0E0D9 2XX FCHS,
0FAD9 2XX FSQRT, 0FDD9 2XX FSCALE, 0F8D9 2XX FPREM,
0FCD9 2XX FRNDINT, ( Арифметические)
0D9DE 2XX FCOMPP, 0E4D9 2XX FTST, 0E5D9 2XX FXAM, ( Сравн.)
0F2D9 2XX FPTAN, 0F3D9 2XX FPATAN, 0F0D9 2XX F2XM1,
0F9D9 2XX FYL2XP1, 0F1D9 2XX FYL2X, ( Трансцендентные)
0E0DB 2XX FENI, 0E2DB 2XX FCLEX, 0E1D8 2XX FDISI,
0E3DB 2XX FINIT, 0F6D9 2XX FDECSTP, 0F7D9 2XX FINCSTP,
0D0D9 2XX FNOP, ( Управления)

\ Assembler. 8087. Адресные команды 1. ->reg e
0DF 0 1XM FILDW, 0DB 0 1XM FILDD, 0DF 5 1XM FILDQ,
0DF 4 1XM FBLD, 0D9 0 1XM FLDD, 0DD 0 1XM FLDQ,
0DB 5 1XM FLDT, 0D9 2 1XM FSTD, 0DD 2 1XM FSTQ,
0D9 3 1XM FSTPD, 0DD 3 1XM FSTPQ, 0DD 7 1XM FSTPT,
0DF 6 1XM FBSTP, 0DF 2 1XM FISTW, 0DB 2 1XM FISTD,
0DF 3 1XM FISTPW, 0DB 3 1XM FISTPD, 0DF 7 1XM FISTPQ, ( Пер.)
0D8 6 1XM FDIVD, 0DC 6 1XM FDIVQ, 0DE 6 1XM FIDIVW,
0DA 6 1XM FIDIVD, 0D8 7 1XM FDIVRD, 0DC 7 1XM FDIVRQ,
0DE 7 1XM FIDIVRW, 0DA 7 1XM FIDIVRD, 0D8 0 1XM FADDD,
0DC 0 1XM FADDQ, 0DE 0 1XM FIADDW, 0DA 0 1XM FIADDD,
0D8 1 1XM FMULD, 0DC 1 1XM FMULQ, 0DE 1 1XM FIMULW,
0DA 1 1XM FIMULD, 0D8 4 1XM FSUBD, 0DC 4 1XM FSUBQ,
0DE 4 1XM FISUBW, 0DA 4 1XM FISUBD, 0D8 5 1XM FSUBRD,
0DC 5 1XM FSUBRQ, 0DE 5 1XM FISUBRW, 0DA 5 1XM FISUBRD, ( Ар.)

\ Assembler. 8087. Адресные команды 2. ->reg e
0D8 2 2XM FCOMD, 0DC 2 2XM FCOMQ, 0D8 3 2XM FCOMPD,
0DC 3 2XM FCOMPQ, 0DE 2 2XM FICOMW, 0DA 2 2XM FICOMD,
0DE 3 2XM FICOMPW, 0DA 3 2XM FICOMPD, ( Сравнения)
0D9 4 2XM FLDENV, 0DD 4 2XM FRSTOR, 0D9 5 2XM FLDCW,
0D9 6 2XM FSTENV, 0D9 7 2XM FSTCW, 0DD 5 2XM FSTSW,
0DD 6 2XM FSAVE, ( Управления)

\ Assembler. 8087. Регистровые команды. reg->
0C0D9 2DX FLD, 0D0DD 2DX FST, 0D8DD 2DX FSTP,
0C8D9 2DX FXCH, ( Пересылки)
0F0D8 2DX FDIV0, 0F8DC 2DX FDIV, 0F8DE 2DX FDIVP,
0F8D8 2DX FDIVR0, 0F0DC 2DX FDIVR, 0F0DE 2DX FDIVRP,
0C0D8 2DX FADD0, 0C0DC 2DX FADD, 0C0DE 2DX FADDP,
0C8D8 2DX FMUL0, 0C8DC 2DX FMUL, 0C8DE 2DX FMULP,
0E0D8 2DX FSUB0, 0E8DC 2DX FSUB, 0E8DE 2DX FSUBP,
0E8D8 2DX FSUBR0, 0E0DC 2DX FSUBR, 0E0DE 2DX FSUBRP, ( Арифм.)
0D0D8 2DX FCOM, 0D8D8 2DX FCOMP, ( Сравнения)
0C0DD 2DX FFREE, ( Управления)

\ Assembler. 80X87. Новые команды.
\ Новые функции.
0F5D9 2XX FPREM1, 0FFD9 2XX FCOS, 0FED9 2XX FSIN,
0FBD9 2XX FSINCOS,
\ Сравнение.
0E0DD 2DX FUCOM, 0E8DD 2DX FUCOMP, 0E9DA 2XX FUCOMPP,
\ Управление.
0E0DF 2XX FSTSWAX,
\ P6. Сравнение. reg->
0C0DA 2DX FCMOVCY, 0C8DA 2DX FCMOVZR, 0D0DA 2DX FCMOVCY|ZR,
0D8DA 2DX FCMOVPE, 0C0DB 2DX FCMOVNC, 0C8DB 2DX FCMOVNZ,
0D0DB 2DX FCMOVNC&NZ, 0D8DB 2DX FCMOVPO,
0F0DB 2DX FCOMI, 0F0DF 2DX FCOMIP, 0E8DB 2DX FUCOMI,
0E8DF 2DX FUCOMIP,

Ну, как-то так. Я опустил аналогичные описанным Барановых & Ноздруновым слова для упаковки кода в словарные статьи и макросы условных переходов.

Как выглядит использование этой лабуды на практике (из Win-FOBOS)?

Слово I для цикла DO (сугубо ВНУТРЕННЕЕ КОДОВОЕ СЛОВО):

CODE I ( -- n) B PUSHR, /DW MOV, B BP [8] -4 C, NEXT, END-CODE

Вызов WIN-API функций (ВНЕШНЕЕ):

CODE CALL ( ..., a -- w)
/WO MOV, BP [DW] EBP-OLD ,
/WO MOV, DI [DW] EDI-OLD ,
CALLEW, B [RG] /DW MOV, B A [RG]
/DW MOV, DI [DW] EDI-OLD , NEXT,
END-CODE

Компиляция строки (скорее, ВВНУТРЕННЕЕ):

CODE (S") ( -- ca, n) ( СТРОКА ДЛИНА)
B PUSHR, /DW MOV, B SI [RG] B INCR, B PUSHR,
/BO MOVZX, A SI [0] /DW MOV, B A [RG]
/DW ADD, SI A [RG] SI INCR, NEXT, END-CODE
: S" ( <строка"> -- ca, n) STATE @ IF COMPILE (S") THEN
34 WORD DUP C@ 1+ ALLOT STATE @ IF DROP ELSE COUNT THEN ; IMMEDIATE

Кстати, слово NEXT, (переход к следующему шитому коду), очевидно, входит в само FORTH-ядро (ПСЕВДОСЛОВО, изначально реализованное ассемблерным макросом).

ВЫВОДЫ.

Написав свой FORTH-ассемблер (DOS-FOBOS), я вдруг заметил, что предпочитаю им не пользоваться, разве что для 32-разрядных участков кода. Для вставки обычных КОДОВЫХ СЛОВ (что ВНЕШНИХ, что ВНУТРЕННИХ) гораздо проще было внести изменения (ПСЕВДОСЛОВА) в ассемблерный код самого FOBOS и перекомпилировать его. Мур-то был прав!

Так что я знаю только две причины применения FORTH-ассемблера:
1) вам удалось написать замкнутую FORTH-систему, в которой можно удобно работать и программировать, не вылезая наружу - во внешнюю Операционную Систему, или
2) вам нужно писать код для процессора (режима), который ваше ПО сборки самой FORTH-системы не поддерживает.
***

Боле того, начав дергать для примера блоки из DOS-FOBOS, я обнаружил, что в конце моего ассемблера была пара блоков с "полезными" макросами часто встречающихся случаев адресации. Интересно, я, хотя бы раз их использовал? Или написал и сразу забыл?
Нет, писать что-то заранее на FORTH, который сам не имеет смысла писать заранее, это вдвойне бесполезная трата времени.