Компилирующий ассемблер

chess

Из-за неудобства пользования ассемблером в СПФ под свои задачи начал делать свой ассемблер.
Вот его наметки. Заранее скажу - способ реализации неоптимален. Тут главное - идея.

Код:

\ Компилирующий ассемблер

0x0 CONSTANT A  \ EAX
0x1 CONSTANT C  \ ECX
0x2 CONSTANT D  \ EDX
0x3 CONSTANT B  \ EBX
0x5 CONSTANT P  \ EBP
0x6 CONSTANT S  \ ESI

\ MOV  R1,  R2
: R=R  \ R1 R2 --
0x8B C, SWAP 3 LSHIFT 0xC0 OR OR C, ;

\ MOV  R1, (SM) [R2]
: R=@R \ (SM) R1 R2 --
DUP >R 0x8B C, SWAP 3 LSHIFT
R> 5 =
IF
  0x40 OR OR C, DEPTH
  IF
    C,
  ELSE
    0x0 C,
  THEN
ELSE
  0x00 OR OR C,
THEN  ;

\ MOV (SM) [R1], R2
: @R=R \ (SM) R1 R2 --
SWAP DUP >R SWAP 0x89 C,  3 LSHIFT
R> 5 =
IF
  0x40 OR OR C, DEPTH
  IF
    C,
  ELSE
    0x0 C,
  THEN
ELSE
  0x00 OR OR C,
THEN  ;

\ LEA R1, (SM) [R2]
: R+SM \ (SM) R1 R2
0x8D C, SWAP 3 LSHIFT 0x40 OR OR C,
DEPTH IF  C, ELSE 0x0 C, THEN ;

: I: HEADER ] HIDE IMMEDIATE ;

I: A=B A B R=R ; I: A=C A C R=R ; I: A=D A D R=R ; I: A=S A S R=R ; I: A=P A P R=R ;
I: B=A B A R=R ; I: B=C B C R=R ; I: B=D B D R=R ; I: B=S B S R=R ; I: B=P B P R=R ;
I: C=A C A R=R ; I: C=B C B R=R ; I: C=D C D R=R ; I: C=S C S R=R ; I: C=P C P R=R ;
I: D=A D A R=R ; I: D=B D B R=R ; I: D=C D C R=R ; I: D=S D S R=R ; I: D=P D P R=R ;
I: S=A S A R=R ; I: S=B S B R=R ; I: S=C S C R=R ; I: S=D S D R=R ; I: S=P S P R=R ;
I: P=A P A R=R ; I: P=B P B R=R ; I: P=C P C R=R ; I: P=D P D R=R ; I: P=S P S R=R ;

I: A=@A A A R=@R ; I: A=@B A B R=@R ; I: A=@C A C R=@R ; I: A=@D A D R=@R ; I: A=@S A S R=@R ;  I: A=@P A P R=@R ;
I: B=@A B A R=@R ; I: B=@B B B R=@R ; I: B=@C B C R=@R ; I: B=@D B D R=@R ; I: B=@S B S R=@R ;  I: B=@P B P R=@R ;
I: C=@A C A R=@R ; I: C=@B C B R=@R ; I: C=@C C C R=@R ; I: C=@D C D R=@R ; I: C=@S C S R=@R ;  I: C=@P C P R=@R ;
I: D=@A D A R=@R ; I: D=@B D B R=@R ; I: D=@C D C R=@R ; I: D=@D D D R=@R ; I: D=@S D S R=@R ;  I: D=@P D P R=@R ;
I: S=@A S A R=@R ; I: S=@B S B R=@R ; I: S=@C S C R=@R ; I: S=@D S D R=@R ; I: S=@S S S R=@R ;  I: S=@P S P R=@R ;
I: P=@A P A R=@R ; I: P=@B P B R=@R ; I: P=@C P C R=@R ; I: P=@D P D R=@R ; I: P=@S P S R=@R ;  I: P=@P P P R=@R ;

I: @A=A A A @R=R ; I: @A=B A B @R=R ; I: @A=C A C @R=R ; I: @A=D A D @R=R ; I: @A=S A S @R=R ;  I: @A=P A P @R=R ;
I: @B=A B A @R=R ; I: @B=B B B @R=R ; I: @B=C B C @R=R ; I: @B=D B D @R=R ; I: @B=S B S @R=R ;  I: @B=P B P @R=R ;
I: @C=A C A @R=R ; I: @C=B C B @R=R ; I: @C=C C C @R=R ; I: @C=D C D @R=R ; I: @C=S C S @R=R ;  I: @C=P C P @R=R ;
I: @D=A D A @R=R ; I: @D=B D B @R=R ; I: @D=C D C @R=R ; I: @D=D D D @R=R ; I: @D=S D S @R=R ;  I: @D=P D P @R=R ;
I: @S=A S A @R=R ; I: @S=B S B @R=R ; I: @S=C S C @R=R ; I: @S=D S D @R=R ; I: @S=S S S @R=R ;  I: @S=P S P @R=R ;
I: @P=A P A @R=R ; I: @P=B P B @R=R ; I: @P=C P C @R=R ; I: @P=D P D @R=R ; I: @P=S P S @R=R ;  I: @P=P P P @R=R ;

I: P+SM P P R+SM ;

\ Примеры 

: dup
[ -4 ] @P=A
[ -4 ] P+SM
;
: drop
A=@P
[ 4 ] P+SM
;
: swap
D=@P
@P=A
A=D
;
: rot
D=@P
@P=A
[ 4 ] A=@P
[ 4 ] @P=D
;
: over
[ -4 ] @P=A
A=@P
[ -4 ] P+SM
;
: over2 \ 1 2  3 --> 1 2 3  1
[ -4 ] @P=A
[  4 ] A=@P
[ -4 ] P+SM
;

REQUIRE SEE       lib\ext\disasm.f

: SEN ' DUP WordByAddr CR CR ." CODE " TYPE  REST ;

STARTLOG

SEN dup
SEN drop
SEN swap
SEN rot
SEN over
SEN over2

ENDLOG

А это лог-файл.

Код:

CODE dup
55A7A0 8945FC      MOV     FC [EBP] , EAX
55A7A3 8D6DFC      LEA     EBP , FC [EBP]
55A7A6 C3          RET     NEAR
END-CODE

CODE drop
55A7C0 8B4500      MOV     EAX , 0 [EBP]
55A7C3 8D6D04      LEA     EBP , 4 [EBP]
55A7C6 C3          RET     NEAR
END-CODE

CODE swap
55A7E0 8B5500      MOV     EDX , 0 [EBP]
55A7E3 894500      MOV     0 [EBP] , EAX
55A7E6 8BC2        MOV     EAX , EDX
55A7E8 C3          RET     NEAR
END-CODE

CODE rot
55A800 8B5500      MOV     EDX , 0 [EBP]
55A803 894500      MOV     0 [EBP] , EAX
55A806 8B4504      MOV     EAX , 4 [EBP]
55A809 895504      MOV     4 [EBP] , EDX
55A80C C3          RET     NEAR
END-CODE

CODE over
55A820 8945FC      MOV     FC [EBP] , EAX
55A823 8B4500      MOV     EAX , 0 [EBP]
55A826 8D6DFC      LEA     EBP , FC [EBP]
55A829 C3          RET     NEAR
END-CODE

CODE over2
55A840 8945FC      MOV     FC [EBP] , EAX
55A843 8B4504      MOV     EAX , 4 [EBP]
55A846 8D6DFC      LEA     EBP , FC [EBP]
55A849 C3          RET     NEAR
END-CODE  

Как видно ассемблер "строит" код слова определяемого через ":" .
Теперь можно сочетать в определении через двоеточие существующие слова с командами ассемблера,
например так:

Код:

: word1  
+  
[ -4 ] @P=A 
@  
D=A  
;

лог-файл

Код:

CODE word1
55A860 034500           ADD     EAX , 0 [EBP]
55A863 8D6D04           LEA     EBP , 4 [EBP]
55A866 8945FC           MOV     FC [EBP] , EAX
55A869 8B00             MOV     EAX , [EAX]
55A86B 8BD0             MOV     EDX , EAX
55A86D C3               RET     NEAR
END-CODE

Обмен информацией между фортом и ассемблером через стек и память.

Постепенно под свои задачи ассемблер можно расширять.

profiT

О! Прикольно. Пригодится.

А то для [url=http://forth.org.ru/~profit/prog\recombinate2.f]recombinate2.f[/url] пришлось небольшой MOV писать.

chess писал(а):

Заранее скажу - способ реализации неоптимален.

А где именно?.. Там же всего-то четыре слова определено (остальные -- порождения их). И сглупить-то негде...

Mihail

chess писал(а):

Из-за неудобства пользования ассемблером в СПФ под свои задачи [b]начал

На какие задачи нехватает эффектиности кода, который генарирует СПФ ?

chess

profiT писал(а):

А где именно?.. Там же всего-то четыре слова определено (остальные -- порождения их). И сглупить-то негде...

Оптимально будет через NOTFOUND(через разбор строк) - наверное потом перейду на него.
Текста в разы меньше будет.

Mihail писал(а):

На какие задачи нехватает эффектиности кода, который генарирует СПФ ?

Если появляется свободное время занимаюсь задачей убирания "лишнего" кода из форт-кода (убирание люфта в коде) на основе семантического представления примитивов форта и получения результирующего семантического представления для их последовательностей. Вот тут и не хватает.

chess

Добавил команды пересылки в регистры и память непосредственных значений:

Код:

\ MOV R, #
: R=#  \ # R --
0xC7 C, 0xC0 OR C, , ;

\ MOV (SM) [R], #
: @R=# \ # (SM) R --
0xC7 C,
DEPTH 2 =
IF
  DUP 5 =
  IF
    0x40 OR C, 0x00 C,
  ELSE
    C,
  THEN
ELSE
  0x40 OR C, C,
THEN
,
;
I: A=# A R=# ; I: B=# B R=# ; I: C=# C R=# ; I: D=# D R=# ; I: P=# P R=# ; I: S=# S R=# ;

I: @A=# A @R=# ; I: @B=# B @R=# ; I: @C=# C @R=# ; I: @D=# D @R=# ; I: @P=# P @R=# ; I: @S=# S @R=# ;

\ примеры
: TST
[ 0x12345678 ] A=#
[ 0x12345678 ] B=#
[ 0x12345678 ] C=#
[ 0x12345678 ] D=#
[ 0x12345678 ] P=#
[ 0x12345678 ] S=#
[ 0x12345678 ] @A=#
[ 0x12345678 ] [ 4 ] @A=#
[ 0x12345678 ] @B=#
[ 0x12345678 ] @C=#
[ 0x12345678 ] @D=#
[ 0x12345678 ] @P=#
[ 0x12345678 ] [ 8 ] @P=#
[ 0x12345678 ] [ -4 ] @S=#
;
REQUIRE SEE       lib\ext\disasm.f

STARTLOG

SEN TST

ENDLOG

лог-файл

Код:

CODE TST
569550 C7C078563412   MOV     EAX , # 12345678
569556 C7C378563412   MOV     EBX , # 12345678
56955C C7C178563412   MOV     ECX , # 12345678
569562 C7C278563412   MOV     EDX , # 12345678
569568 C7C578563412   MOV     EBP , # 12345678
56956E C7C678563412   MOV     ESI , # 12345678
569574 C70078563412   MOV     [EAX] , # 12345678
56957A C7400478563412 MOV     4 [EAX] , # 12345678
569581 C70378563412   MOV     [EBX] , # 12345678
569587 C70178563412   MOV     [ECX] , # 12345678
56958D C70278563412   MOV     [EDX] , # 12345678
569593 C7450078563412 MOV     0 [EBP] , # 12345678
56959A C7450878563412 MOV     8 [EBP] , # 12345678
5695A1 C746FC78563412 MOV     FC [ESI] , # 12345678
5695A8 C3             RET     NEAR
END-CODE  

profiT

[CODE]DEPTH 2 = IF[CODE]
Таких вещей не просто нельзя делать в Форте...

Их Н-Е-Л-Ь-З-Я делать в Форте.

Зачем нужно такие типа-пропускаемые аргументы функций? После этого слова совершенно невозможно использовать в программе.

chess

profiT писал(а):

CODE]DEPTH 2 = IF[CODE]
Таких вещей не просто нельзя делать в Форте...

Их Н-Е-Л-Ь-З-Я делать в Форте.

Зачем нужно такие типа-пропускаемые аргументы функций? После этого слова совершенно невозможно использовать в программе.

Почему нельзя. Слово DEPTH как раз и позволяет это делать.
Дай хотя-бы один пример когда совершенно невозможно использовать такие слова.

Hishnik

А я вот все смотрю и думаю - а разве бывают некомпилирующие ассемблеры?

profiT

chess писал(а):

Дай хотя-бы один пример когда совершенно невозможно использовать такие слова.

Да могу дать хоть миллион. Но дам, для большей понятности, только 792 134-й (хе-хе):

Код:

: ?DUP IF
[ -4 ] @P=A 
[ -4 ] P+SM
THEN ;

chess

Хищник писал(а):

А я вот все смотрю и думаю - а разве бывают некомпилирующие ассемблеры?

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

Hishnik

chess писал(а):

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

А вопрос в чем? Сделать еще один движок ассемблера? С перебором вариантов аргументов - это сложно. Тем более что с проверкой глубины стека - это очень ненадежно. Оно в тестах будет очень красивым, а в реальном проекте рухнет.

chess

profiT писал(а):

: ?DUP IF
[ -4 ] @P=A
[ -4 ] P+SM
THEN ;

Так слово ?DUP определено неправильно (IF снимает параметр со стека - и что дальше дублировать?).
По смыслу ?DUP это
: ?DUP DUP IF DUP THEN ;
Поэтому приведенный пример некорректен.

В СПФ ?DUP определен так:

Код:

: ?DUP   STATE @
                 IF  HERE TO :-SET
                      ['] C-?DUP  INLINE,
                     HERE TO :-SET
                 ELSE ?DUP
                 THEN ;   IMMEDIATE

Вообще определено как слово немедленного исполнения(по-моему замутили).
Для C-?DUP имеем (для состояния компиляции - компилим этот код )

Код:

CODE C-?DUP
     OR  EAX, EAX
     JZ SHORT @@1
     LEA EBP, -4 [EBP]
     MOV [EBP], EAX
@@1: RET
END-CODE 

В состоянии исполнения исполняется этот же код.
Непонятно зачем все это так сделано.
Ну сделали бы так:

Код:

CODE ?DUP
     OR  EAX, EAX
     JZ SHORT @@1
     LEA EBP, -4 [EBP]
     MOV [EBP], EAX
@@1: RET
END-CODE

chess

Хищник писал(а):

А вопрос в чем? Сделать еще один движок ассемблера? С перебором вариантов аргументов - это сложно. Тем более что с проверкой глубины стека - это очень ненадежно. Оно в тестах будет очень красивым, а в реальном проекте рухнет.

Под свои задачи мне не нужен полный ассемблер. Мне нужен другой синтаксис (слова ассемблера в словаре FORTH, а не в словаре ASSM), ассемблерные команды работают внутри определений через двоеточие, слова немедленного исполнения, ранее определенные в Форте, передают через стек параметры ассемблерным командам и т.п.

Hishnik

Кстати, я же бросал недавно постфиксный ассемблер. Куда уж проще? Именно внутри определений через двоеточие, можно вводить команды "забрать со стека в регистр", "положить на стек из регистра". Главное, я его не фиксирую, как МОЙ продукт. Там основная сложность - ведение таблицы меток и работа с ней. Сложность - в кавычках, потому что все остальное еще проще. Можно хотя бы посмотреть, потому что если такое писать с нуля и самому, то через 5-10 минут набора текста эта штука уже сможет генерировать код.

profiT

chess писал(а):

Поэтому приведенный пример некорректен.

Конечно, некорректен (или даже некорректен). Потому что @P=A думает что оно будет запускаться или с двумя элементами на стеке или с тремя элементами на стеке всего. А вот то что на стеке может (и должно) лежать хоть сто значений не учитывается.

И IF как раз оставляет такие значения на стеке в режиме компиляции.

А код да, неверен...

Компилирующий ассемблер

Кто сейчас на конференции