1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
: cell+ 8 + ;
: syswrite ( u c-addr fd -- n ) 1 syscall3 ;
: say ( c-addr u -- ) swap 2 syswrite drop ;
: emit ( chr -- ) sp cell+ 1 swap 1 syswrite 2drop ;
: cr 10 emit ;
: decimal 10 base ! ;
: hex 16 base ! ;
: nip swap drop ;
: tuck swap over ;
hex : ret, c3 c, ; decimal
: cells 8 * ;
: allot here @ swap here +! ;
: [compile] parse find drop >cfa compile, ; immediate
: ' parse find drop >cfa [compile] lit ; immediate \ note: no error handling (yet)
: recurse latest @ >cfa compile, ; immediate
: literal [compile] lit ; immediate
: constant create [compile] lit ret, ;
: variable 1 cells allot create [compile] lit ret, ;
\ https://wiki.osdev.org/X86-64_Instruction_Encoding
\ see dusk os asm/x86.fs
\ my idea is that operands are given in the reverse order that
\ they are in intel notation, so that intel notation can be vaguely
\ turned into this assembler by moving the mnemonic to the end,
\ like: mov r11, r12 -> smth like r11 r12 mov,
\ a lot of this would probably be more elegant but i have to get around
\ to <builds and does>. i don't want to have to
hex
variable rex
variable modrm
: asm$ 0 rex ! c0 modrm ! ;
: rex.w rex @ 48 or rex ! ;
: rex.r rex @ 44 or rex ! ;
: rex.x rex @ 42 or rex ! ;
: rex.b rex @ 41 or rex ! ;
\ REGISTERS {{{
: rax modrm @ 0 or modrm ! ; : rcx modrm @ 1 or modrm ! ;
: rdx modrm @ 2 or modrm ! ; : rbx modrm @ 3 or modrm ! ;
: rsp modrm @ 4 or modrm ! ; : rbp modrm @ 5 or modrm ! ;
: rsi modrm @ 6 or modrm ! ; : rdi modrm @ 7 or modrm ! ;
: r8 modrm @ 0 or modrm ! rex.b ; : r9 modrm @ 1 or modrm ! rex.b ;
: r10 modrm @ 2 or modrm ! rex.b ; : r11 modrm @ 3 or modrm ! rex.b ;
: r12 modrm @ 4 or modrm ! rex.b ; : r13 modrm @ 5 or modrm ! rex.b ;
: r14 modrm @ 6 or modrm ! rex.b ; : r15 modrm @ 7 or modrm ! rex.b ;
: rax, modrm @ 00 or modrm ! ; : rcx, modrm @ 08 or modrm ! ;
: rdx, modrm @ 10 or modrm ! ; : rbx, modrm @ 18 or modrm ! ;
: rsp, modrm @ 20 or modrm ! ; : rbp, modrm @ 28 or modrm ! ;
: rsi, modrm @ 30 or modrm ! ; : rdi, modrm @ 38 or modrm ! ;
: r8, modrm @ 00 or modrm ! rex.r ; : r9, modrm @ 08 or modrm ! rex.r ;
: r10, modrm @ 10 or modrm ! rex.r ; : r11, modrm @ 18 or modrm ! rex.r ;
: r12, modrm @ 20 or modrm ! rex.r ; : r13, modrm @ 28 or modrm ! rex.r ;
: r14, modrm @ 30 or modrm ! rex.r ; : r15, modrm @ 38 or modrm ! rex.r ;
\ }}}
: /0 modrm @ 00 or modrm ! ; : /1 modrm @ 08 or modrm ! ;
: /2 modrm @ 10 or modrm ! ; : /3 modrm @ 18 or modrm ! ;
: /4 modrm @ 20 or modrm ! ; : /5 modrm @ 28 or modrm ! ;
: /6 modrm @ 30 or modrm ! ; : /7 modrm @ 38 or modrm ! ;
\ example idea: (from execute below)
\ rex.w r11, r14 0 d) mov,
\ rex.w r14, r14 8 d) lea,
\ r11 call,
decimal
: execute [ hex
4d c, 8b c, 1e c, \ mov r11, [r14]
\ REX.W + 8B /r -- MOV r64, r/m64
\ rex w (64 bit operand size), r (modrm.reg ext), b (modrm.rm ext)
\ modrm 00 011 110
\ mod [r/m] reg 1.011 (r11) r/m 1.110 (r14)
4d c, 8d c, 76 c, 08 c, \ lea r14, [r14+8]
\ REX.W + 8D /r -- LEA r64, m
\ rex w (64 bit operand size), r (modrm.reg ext), b (modrm.rm ext)
\ modrm 01 110 110
\ mod [r/m+disp8] reg 1.110 (r14) r/m 1.110 (r14)
41 c, ff c, d3 c, \ call r11
\ FF /2 -- CALL r/m64
\ rex b (.rm ext)
\ modrm 11 010 011
\ mod r/m reg /2 r/m 1.011 (r11)
decimal ] ;
\ TODO interpret mode strings?
: s" [ char " ] literal 1 >in +! ( skip spc ) [compile] litstring ; immediate
: ." [compile] s" ' say compile, ; immediate \ lol this word breaks the highlighting, here have another "
\ jump helpers from forth83 (got them from pforth tho ehehe)
\ < backward jump > forward jump
\ adding/subtracting 4 gets to the next instruction.
: <mark here @ ;
: <resolve here @ 4 + - d, ;
: >mark here @ 0 d, ;
: >resolve dup here @ swap - 4 - swap d! ;
: begin <mark ; immediate
: again branch <resolve ; immediate \ add 4 to get to beginning of the next instruction
: until 0branch <resolve ; immediate
: if 0branch >mark ; immediate ( I: -- a )
: else branch >mark swap >resolve ; immediate
: then >resolve ; immediate
: while 0branch >mark ; immediate
: repeat branch swap <resolve >resolve ; immediate
: / /mod swap drop ;
: mod /mod drop ;
: negate 0 swap - ;
: abs dup 0< if negate then ;
32 constant bl
: space bl emit ;
: spaces begin dup 0> while space 1- repeat drop ;
\ PNO
\ mostly from pforth
255 allot variable pad drop
variable hld
: <# pad hld ! ;
: hold 1 hld -! ( chr ) hld @ c! ;
: sign 0< if [ char - ] literal hold then ;
: # base @ /mod swap 9 over > if 7 + then [ char 0 ] literal + hold ;
: #s begin # dup 0= until ;
: #> drop hld @ pad over - ;
: (u.) <# #s #> ;
: u. (u.) say space ;
: u.r >r (u.) r> over - spaces say ;
: (.) dup abs <# #s swap sign #> ;
: . (.) say space ;
: .r >r (.) r> over - spaces say ;
: (.byte) hex <# # # #> decimal ;
: .byte (.byte) say space ;
: (.word) hex <# # # # # #> decimal ;
: .word (.word) say space ;
: (.dword) hex <# # # # # # # # # #> decimal ;
: .dword (.dword) say space ;
: (.qword) hex <# # # # # # # # # # # # # # # # # #> decimal ;
: .qword (.qword) say space ;
: ? @ . ;
: .s sp 8 + ( skip sp itself ) begin dup s0 @ >= while dup @ .qword 8 + repeat drop cr ;
bye
|
