Debian Codegraph @

lib/lang/asm/x86_64.scm

raw
1 ;;;
2 ;;; x86_64 minimum assembler
3 ;;;
4 ;;; Copyright (c) 2015-2024 Shiro Kawai <[email protected]>
5 ;;;
6 ;;; Redistribution and use in source and binary forms, with or without
7 ;;; modification, are permitted provided that the following conditions
8 ;;; are met:
9 ;;;
10 ;;; 1. Redistributions of source code must retain the above copyright
11 ;;; notice, this list of conditions and the following disclaimer.
12 ;;;
13 ;;; 2. Redistributions in binary form must reproduce the above copyright
14 ;;; notice, this list of conditions and the following disclaimer in the
15 ;;; documentation and/or other materials provided with the distribution.
16 ;;;
17 ;;; 3. Neither the name of the authors nor the names of its contributors
18 ;;; may be used to endorse or promote products derived from this
19 ;;; software without specific prior written permission.
20 ;;;
21 ;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 ;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 ;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 ;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 ;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 ;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 ;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28 ;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29 ;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30 ;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31 ;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 ;;;
33
34 ;; EXPERIMENTAL - At this moment, this module is mainly "to play with" x86_64
35 ;; instructions. This is not a full set assembler; we implement features
36 ;; on demand.
37 ;; TODO: Eventually we might want to split machine-independent front-end
38 ;; to lang.asm. The API will very likely change then.
39
40 (define-module lang.asm.x86_64
41 (use gauche.uvector)
42 (use gauche.sequence)
43 (use scheme.list)
44 (use srfi.13)
45 (use srfi.42)
46 (use lang.asm.regset)
47 (use util.match)
48 (export asm asm-dump)
49 )
50 (select-module lang.asm.x86_64)
51
52 ;; Instruction notation
53 ;; (<opcode>)
54 ;; (<opcode> <operand1>)
55 ;; (<opcode> <operand1> <operand2>)
56 ;;
57 ;; Operand
58 ;; %reg
59 ;; (%reg)
60 ;; imm
61 ;; (imm)
62 ;; (off %base)
63 ;; (%base %index)
64 ;; (%base %index scale)
65 ;; (off %base %index scale)
66 ;;
67 ;; %reg, %base, %index : Symbol beginning with '%' to name a register.
68 ;; imm, off : An integer. Some instructions have variations depending
69 ;; on the operand width, which is automatically handled.
70 ;; scale: 1, 2, 4, or 8
71 ;;
72 ;; For most operands, we require having data width suffix (e.g. movb for
73 ;; byte, movq for quad). Not all widths are supported.
74 ;;
75 ;; For jump instruction with label, %rip-relative addressing is used.
76 ;; TODO: (mov LABEL %reg) may also use %rip-relative. Since we don't
77 ;; have linkers, the absolute address of LABEL will never be known.
78 ;; (Or, we could add an on-memory linker...)
79
80 ;;-----------------------------------------------------------------
81 ;; Entry and x86 ISA definitions (subset)
82 ;;
83
84 ;; asm :: [Insn] -> [Byte], [(label . addr)]
85 ;; Main entry. Takes a sequence of assembly (in S-expr), and returns
86 ;; two values: sequence of machine code bytes, and an alist of label to
87 ;; relative address mapping.
88 (define (asm insns)
89 (let* ([a-map (run-pass1 insns)]
90 [bss (run-pass2 a-map)])
91 (values (concatenate bss) ; instructions
92 (filter-map (^p (and (symbol? (car p)) p)) a-map))))
93
94 ;; run-pass1 :: [Insn] -> [(p, addr)]
95 ;; First pass. create an abstract mapping [(p, xaddr)], where
96 ;; p :: Symbol ; in case of label
97 ;; | (Int,[(Symbol,Int)]) -> [Byte] ; closure to generate machine codes
98 ;; and addr is a value of PC after the code is fetched.
99 (define (run-pass1 insns)
100 (values-ref
101 (map-accum (match-lambda*
102 [((? symbol? label) addr) (values (cons label addr) addr)]
103 [(insn addr) (let* ((p (asm1 (parse-insn insn)))
104 (dummy (p addr #f))
105 (naddr (+ addr (length dummy))))
106 (values (cons p naddr) naddr))])
107 0 insns)
108 0))
109
110 ;; run-pass2 :: [(p, xaddr)] -> [[Byte]]
111 ;; Takes the result of first pass, calling the closure P to realize the
112 ;; actual machine codes.
113 (define (run-pass2 a-map)
114 (reverse (fold (^[p+addr seed]
115 (match-let1 (p . addr) p+addr
116 (if (symbol? p)
117 seed ;ignore labels
118 (cons (p addr a-map) seed))))
119 '() a-map)))
120
121 ;; asm-dump :: [Insn] -> ()
122 ;; For debugging. Show the assembly results in human-readable way.
123 (define (asm-dump insns)
124 (let* ([a-map (run-pass1 insns)]
125 [bss (run-pass2 a-map)])
126 (let loop ((insns insns) (a-map a-map) (bss bss))
127 (unless (null? insns)
128 (match-let1 (_ . addr) (car a-map)
129 (if (symbol? (car insns)) ;label
130 (begin
131 (format #t "~4d:~24a ~a:\n" addr "" (car insns))
132 (loop (cdr insns) (cdr a-map) bss))
133 (let1 byte-slices (slices (car bss) 8)
134 (define (bytedump bytes)
135 (with-output-to-string
136 (^[] (dolist [b bytes] (format #t " ~2,'0x" b)))))
137 (format #t "~4d:~24a ~s\n"
138 addr
139 (bytedump (if (pair? byte-slices)
140 (car byte-slices)
141 '()))
142 (car insns))
143 (when (pair? byte-slices)
144 (dolist [bytes (cdr byte-slices)]
145 (format #t " :~24a\n" (bytedump bytes))))
146 (loop (cdr insns) (cdr a-map) (cdr bss)))))))))
147
148 ;; asm1 :: ParsedInsn -> (Int, [Symbol,Int]) -> [Byte]
149 ;; Called in pass 1. The heart of instruction to machine code mapping.
150 ;; Returns a closure to generate the byte sequence of machine instructions.
151 ;; The closure will take (1) The address of *next* instruction, and
152 ;; (2) an assoc list of labels to addresses.
153 (define (asm1 pinsn)
154 (define ! expand-spec)
155 (define w rex.w)
156 (match pinsn
157 ;; call and ret. we don't care "far" calls/returns.
158 [`(call (imm32 ,i)) (! (opc #xe8) (imm32 i))]
159 [`(call (reg ,r)) (! (opc #xff) (reg 2) (r/m-reg r))]
160 [`(call (mem . ,x)) (! (opc #xff) (reg 2) (mem x))]
161 [`(ret) (! (opc #xc3))]
162
163 [`(push (reg ,n)) (! (rex.b n) (opc+rq #x50 n))]
164 [`(pop (reg ,n)) (! (rex.b n) (opc+rq #x58 n))]
165
166 ;; jumps. for the time being, we ask programmers to explicitly specify
167 ;; whether the jump is short or long.
168 [`(jmp (reg ,t)) (! (opc #xff) (reg 4) (r/m-reg t))]
169 [`(jmp (mem . ,x)) (! (opc #xff) (reg 4) (mem x))]
170 [`(jmp (label ,t)) (op-jump t #t #xeb)]
171 [`(jmpl (label ,t)) (op-jump t #f #xe9)]
172 [`(jo (label ,t)) (op-jump t #t #x70)]
173 [`(jol (label ,t)) (op-jump t #f '(#x0f #x80))]
174 [`(jno (label ,t)) (op-jump t #t #x71)]
175 [`(jnol (label ,t)) (op-jump t #f '(#x0f #x81))]
176 [`(jb (label ,t)) (op-jump t #t #x72)]
177 [`(jc (label ,t)) (op-jump t #t #x72)]
178 [`(jnae (label ,t)) (op-jump t #t #x72)]
179 [`(jbl (label ,t)) (op-jump t #f '(#x0f #x82))]
180 [`(jcl (label ,t)) (op-jump t #f '(#x0f #x82))]
181 [`(jnael(label ,t)) (op-jump t #f '(#x0f #x82))]
182 [`(jnb (label ,t)) (op-jump t #t #x73)]
183 [`(jnc (label ,t)) (op-jump t #t #x73)]
184 [`(jae (label ,t)) (op-jump t #t #x73)]
185 [`(jnbl (label ,t)) (op-jump t #f '(#x0f #x83))]
186 [`(jncl (label ,t)) (op-jump t #f '(#x0f #x83))]
187 [`(jael (label ,t)) (op-jump t #f '(#x0f #x83))]
188 [`(jz (label ,t)) (op-jump t #t #x74)]
189 [`(je (label ,t)) (op-jump t #t #x74)]
190 [`(jzl (label ,t)) (op-jump t #f '(#x0f #x84))]
191 [`(jel (label ,t)) (op-jump t #f '(#x0f #x84))]
192 [`(jnz (label ,t)) (op-jump t #t #x75)]
193 [`(jne (label ,t)) (op-jump t #t #x75)]
194 [`(jnzl (label ,t)) (op-jump t #f '(#x0f #x85))]
195 [`(jnel (label ,t)) (op-jump t #f '(#x0f #x85))]
196 [`(jbe (label ,t)) (op-jump t #t #x76)]
197 [`(jna (label ,t)) (op-jump t #t #x76)]
198 [`(jbel (label ,t)) (op-jump t #f '(#x0f #x86))]
199 [`(jnal (label ,t)) (op-jump t #f '(#x0f #x86))]
200 [`(jnbe (label ,t)) (op-jump t #t #x77)]
201 [`(ja (label ,t)) (op-jump t #t #x77)]
202 [`(jnbel(label ,t)) (op-jump t #f '(#x0f #x87))]
203 [`(jal (label ,t)) (op-jump t #f '(#x0f #x87))]
204 [`(js (label ,t)) (op-jump t #t #x78)]
205 [`(jsl (label ,t)) (op-jump t #f '(#x0f #x88))]
206 [`(jns (label ,t)) (op-jump t #t #x79)]
207 [`(jnsl (label ,t)) (op-jump t #f '(#x0f #x89))]
208 [((or 'jp 'jpe) ('label t)) (op-jump t #t #x7a)]
209 [((or 'jpl 'jpel) ('label t)) (op-jump t #f '(#x0f #x8a))]
210 [((or 'jnp 'jpo) ('label t)) (op-jump t #t #x7b)]
211 [((or 'jnpl 'jpol) ('label t)) (op-jump t #f '(#x0f #x8b))]
212 [((or 'jl 'jnge) ('label t)) (op-jump t #t #x7c)]
213 [((or 'jll 'jngel) ('label t)) (op-jump t #f '(#x0f #x8c))]
214 [((or 'jnl 'jge) ('label t)) (op-jump t #t #x7d)]
215 [((or 'jnll 'jgel) ('label t)) (op-jump t #f '(#x0f #x8d))]
216 [((or 'jle 'jng) ('label t)) (op-jump t #t #x7e)]
217 [((or 'jlel 'jngl) ('label t)) (op-jump t #f '(#x0f #x8e))]
218 [((or 'jnle 'jg) ('label t)) (op-jump t #t #x7f)]
219 [((or 'jnlel 'jgl) ('label t)) (op-jump t #f '(#x0f #x8f))]
220
221 ;; trap
222 [('int3) (! (opc #xcc))]
223 [['endbr64] (! (opc '(#xf3 #x0f #x1e #xfa)))]
224
225 ;; moving data around
226 [`(movb (reg8 ,src)(reg8 ,dst))(! (opc #x88) (reg src) (r/m-reg dst))]
227 [`(movb (reg8 ,src)(mem . ,x)) (! (opc #x88) (reg src) (mem x))]
228 [`(movb (mem . ,x) (reg8 ,dst))(! (opc #x8a) (reg dst) (mem x))]
229 [`(movb (imm8 ,i) (reg8 ,dst))(! (opc+rq #xb0 dst) (imm8 i))]
230 [`(movb (imm8 ,i) (mem . ,x)) (! (opc #xc6) (reg 0) (mem x) (imm8 i))]
231
232 [`(movq (imm8 ,i) (reg ,dst)) (! w (opc #xc7) (reg 0) (r/m-reg dst) (imm32 i))]
233 [`(movq (imm32 ,i) (reg ,dst)) (! w (opc #xc7) (reg 0) (r/m-reg dst) (imm32 i))]
234 [`(movq (imm8 ,i) (mem . ,x)) (! w (opc #xc7) (reg 0) (mem x) (imm32 i))]
235 [`(movq (imm32 ,i) (mem . ,x)) (! w (opc #xc7) (reg 0) (mem x) (imm32 i))]
236 [`(movq (imm64 ,i) (reg ,dst)) (! w (rex.b dst) (opc+rq #xb8 dst) (imm64 i))]
237 [`(movq (label ,l) (reg ,dst)) (op-movlabel l dst)]
238 [`(movq (reg ,src) (reg ,dst)) (! w (opc #x89) (reg src) (r/m-reg dst))]
239 [`(movq (reg ,src) (mem . ,x)) (! w (opc #x89) (reg src) (mem x))]
240 [`(movq (mem . ,x) (reg ,dst)) (! w (opc #x8b) (reg dst) (mem x))]
241
242 [`(movzbq (mem . ,x) (reg ,dst)) (! w (opc'(#x0f #xb6)) (reg dst) (mem x))]
243 [`(movzwq (mem . ,x) (reg ,dst)) (! w (opc'(#x0f #xb7)) (reg dst) (mem x))]
244
245 [`(leaq (mem . ,x) (reg ,dst)) (! w (opc #x8d) (reg dst) (mem x))]
246
247 [`(movsd (sse ,src) (sse ,dst)) (! (opc'(#xf2 #x0f #x10)) (reg dst) (r/m-reg dst))]
248 [`(movsd (mem . ,x) (sse ,dst)) (! (opc'(#xf2 #x0f #x10)) (reg dst) (mem x))]
249 [`(movsd (sse ,src) (mem . ,x)) (! (opc'(#xf2 #x0f #x11)) (reg src) (mem x))]
250
251 ;; calculations
252 [('addq _ _) (op-add pinsn 0)]
253 [('orq _ _) (op-add pinsn 1)]
254 [('adcq _ _) (op-add pinsn 2)]
255 [('sbbq _ _) (op-add pinsn 3)]
256 [('andq _ _) (op-add pinsn 4)]
257 [('subq _ _) (op-add pinsn 5)]
258 [('xorq _ _) (op-add pinsn 6)]
259 [('cmpq _ _) (op-add pinsn 7)]
260
261 ;; shifts and rotation
262 [('rol _ _) (op-shift pinsn 0)]
263 [('ror _ _) (op-shift pinsn 1)]
264 [('rcl _ _) (op-shift pinsn 2)]
265 [('rcr _ _) (op-shift pinsn 3)]
266 [('shl _ _) (op-shift pinsn 4)]
267 [('shr _ _) (op-shift pinsn 5)]
268 [('sar _ _) (op-shift pinsn 7)]
269
270 ;; inc and dec
271 [('incq _) (op-inc pinsn 0)]
272 [('decq _) (op-inc pinsn 1)]
273
274 ;; embedded data
275 [`(.datab ,(_ i) ...) (^(a t) (append-map int8 i))]
276 [`(.datal ,(_ i) ...) (^(a t) (append-map int32 i))]
277 [`(.dataq ,(_ i) ...) (^(a t) (append-map int64 i))]
278 [`(.datas (str ,s)) (^(a t) (fold-right cons '(0) (string->u8vector s)))]
279 [`(.align ,(_ i)) (^(a t) (make-list (- (round-up a i) a) 0))]
280 ))
281
282 ;; jump family
283 (define (op-jump target short? opcode)
284 (define immX (if short? imm8 imm32))
285 (define immX? (if short? imm8? imm32?))
286 (^[addr label-alist]
287 (cond [(not label-alist)
288 ((expand-spec (opc opcode) (immX 0)) 0 0)] ; dummy
289 [(assq-ref label-alist target)
290 => (^[taddr]
291 (unless (immX? (- taddr addr))
292 (error "jump target out of range:" target))
293 ((expand-spec (opc opcode) (immX (- taddr addr))) 0 0))]
294 [else (error "jump destination doesn't exist:" target)])))
295
296 ;; special case to load label's address into a register.
297 ;; NB: in most cases, absolute value of label address is irrelevant,
298 ;; for we don't have linker that handles relocation.
299 (define (op-movlabel label dst)
300 (define ! expand-spec)
301 (define w rex.w)
302 (^[addr label-alist]
303 (if label-alist
304 (let1 laddr (assq-ref label-alist label)
305 (unless laddr (error "undefined label:" label))
306 (warn "Using absolute address of label may not what you want to do. \
307 Consider using leaq label(%rip) instead.\n")
308 ((! w (rex.b dst) (opc+rq #xb8 dst) (imm64 laddr)) 0 0))
309 ((! w (rex.b dst) (opc+rq #xb8 dst) (imm64 0)) 0 0)))) ;; dummy
310
311 ;; addq family
312 ;; opcode variations are derived from a single number, regc.
313 (define (op-add pinsn regc)
314 (define ! expand-spec)
315 (define w rex.w)
316 (define basc (+ (ash regc 3) 1))
317 (define raxc (+ (ash regc 3) 5))
318 (match pinsn
319 [`(,_ (imm8 ,i) (reg ,dst)) (! w (opc #x83) (reg regc) (r/m-reg dst) (imm8 i))]
320 [`(,_ (imm8 ,i) (mem . ,x)) (! w (opc #x83) (reg regc) (mem x) (imm8 i))]
321 [`(,_ (imm32 ,i) (reg ,dst)) (if (= dst 0) ; %rax
322 (! w (opc raxc) (imm32 i))
323 (! w (opc #x81) (reg regc) (r/m-reg dst) (imm32 i)))]
324 [`(,_ (imm32 ,i) (mem . ,x)) (! w (opc #x81) (reg regc) (imm32 i))]
325 [`(,_ (reg ,src) (reg ,dst)) (! w (opc basc) (reg src) (r/m-reg dst))]
326 [`(,_ (reg ,src) (mem . ,x)) (! w (opc basc) (reg src) (mem x))]
327 [`(,_ (mem . ,x) (reg ,dst)) (! w (opc (+ basc 2)) (reg dst) (mem x))]
328 ))
329
330 ;; shift family
331 (define (op-shift pinsn regc)
332 (define ! expand-spec)
333 (define w rex.w)
334 (match pinsn
335 [`(,_ (imm8 1) (reg ,r)) (! w (opc #xd1) (reg regc) (r/m-reg r))]
336 [`(,_ (imm8 1) (mem . ,x)) (! w (opc #xd1) (reg regc) (mem x))]
337 [`(,_ (imm8 ,i) (reg ,r)) (! w (opc #xc1) (reg regc) (r/m-reg r) (imm8 i))]
338 [`(,_ (imm8 ,i) (mem . ,x)) (! w (opc #xc1) (reg regc) (mem x) (imm8 i))]
339 [`(,_ (reg %cl) (reg ,r)) (! w (opc #xd3) (reg regc) (r/m-reg r))]
340 [`(,_ (reg %cl) (mem . ,x)) (! w (opc #xd3) (reg regc) (mem x))]
341 ))
342
343 ;; inc and dec
344 (define (op-inc pinsn regc)
345 (define ! expand-spec)
346 (define w rex.w)
347 (match pinsn
348 [`(,_ (reg ,r)) (! w (opc #xff) (reg regc) (r/m-reg r))]
349 [`(,_ (mem . ,x)) (! w (opc #xff) (reg regc) (mem x))]
350 ))
351
352 ;; for align
353 (define (round-up addr modu)
354 (* (quotient (+ addr modu -1) modu) modu))
355
356 ;;-----------------------------------------------------------------
357 ;; Asm parser & machine code generators
358 ;;
359
360 (define (parse-insn insn)
361 (match insn
362 [(opc . oprs) `(,opc ,@(map parse-operand oprs))]
363 [_ (error "invalid insn:" insn)]))
364
365 (define (parse-operand opr)
366 (match opr
367 [(? reg64?) `(reg ,(regnum opr))]
368 [(? regsse?) `(sse ,(ssenum opr))]
369 [(? reg8?) `(reg8 ,(regnum8 opr))]
370 [(? symbol?) `(label ,opr)]
371 [(? string?) `(str ,opr)] ; C string literal
372 [(? imm8?) `(imm8 ,opr)]
373 [(? imm32?) `(imm32 ,opr)]
374 [(? imm64?) `(imm64 ,opr)]
375 [('imm8 val) `(imm8 ,val)]
376 [('imm32 val) `(imm32 ,val)]
377 [('imm64 val) `(imm64 ,val)]
378 [((? integer? a)) `(mem addr ,a)]
379 [((? reg64? b)) `(mem base ,(regnum b))]
380 [((? symbol? l)) `(mem label ,l)]
381 [((? integer? d) (? reg64b? b)) `(mem base+disp ,(regnumb b) ,d)]
382 [((? symbol? l) (? reg64b? b)) `(mem base+disp ,(regnumb b) label ,l)]
383 [((? reg64? b) (? reg64? i)) `(mem sib ,(regnum b) ,(regnum i) 1 0)]
384 [((? integer? d) (? reg64? b) (? reg64? i))
385 `(mem sib ,(regnum b) ,(regnum i) 1 ,d)]
386 [((? reg64? b) (? reg64? i) (? scale? s))
387 `(mem sib ,(regnum b) ,(regnum i) ,s 0)]
388 [((? integer? d) (? reg64? b) (? reg64? i) (? scale? s))
389 `(mem sib ,(regnum b) ,(regnum i) ,s ,d)]
390 [_ (error "invalid operand:" opr)]))
391
392 (define (expand-spec . modifiers)
393 (^[addr label-alist]
394 (generate-bincode (fold (cut <> <> addr label-alist) '() modifiers))))
395
396 (define (generate-bincode spec)
397 (let-keywords* spec ((rex.w #f) (rex.r #f) (rex.x #f) (rex.b #f) ;REX
398 (opcode #f)
399 (mode #f) (reg #f) (r/m #f) ;modrm
400 (scale 1) (index #f) (base #f) ;sib
401 (displacement #f)
402 (immediate #f))
403 (cond-list
404 [(or rex.w rex.r rex.x rex.b) (pack-rex rex.w rex.r rex.x rex.b)]
405 [#t @ (if (list? opcode) opcode `(,opcode))]
406 [(or mode reg r/m) (pack-modrm mode reg r/m)]
407 [(or index base) (pack-sib scale index base)]
408 [displacement @]
409 [immediate @])))
410
411 ;; REX prefix
412 ;; w - operand width. #t - 64bit
413 ;; r - modrm reg register +8
414 ;; x - sib index register +8
415 ;; b - modrm r/m register +8
416 (define (pack-rex w r x b)
417 (+ #x40 (if w 8 0) (if r 4 0) (if x 2 0) (if b 1 0)))
418
419 ;; MODRM byte
420 ;; reg - %rax--%rdi (REX.r=0) or %r8--%r15 (REX.r = 1)
421 ;; case mod
422 ;; 00 r/m - REX.b=0: [%rax %rcx %rdx %rbx SIB RIP+disp32 %rsi %rdi]
423 ;; REX.b=1: [%r8 %r9 %r10 %r11 SIB RIP+disp32 %r14 %r15]
424 ;; 01 r/m - REX.b=0: [%rax %rcx %rdx %rbx SIB %rbp %rsi %rdi] + disp8
425 ;; REX.b=1: [%r8 %r9 %r10 %r11 SIB %r13 %r14 %r15] + disp8
426 ;; 10 r/m - REX.b=0: [%rax %rcx %rdx %rbx SIB %rbp %rsi %rdi] + disp32
427 ;; REX.b=1: [%r8 %r9 %r10 %r11 SIB %r13 %r14 %r15] + disp32
428 ;; 11 r/m - REX.b=0: %rax %rcx %rdx %rbx %rsp %rbp %rsi %rdi
429 ;; %al %cl %dl %bl %ah %ch %dh %bh
430 ;; %al %cl %dl %bl %spl %bpl %sil %dil
431 ;; REX.b=1: %r8 %r9 %r10 %r11 %r12 %r13 %r14 %r15
432
433 (define (pack-modrm mod reg r/m)
434 (pack-byte233 (or mod 0) (or reg 0) (or r/m 0)))
435
436 (define (pack-byte233 x y z)
437 (+ (ash (logand x 3) 6) (ash (logand y 7) 3) (logand z 7)))
438
439 ;; SIB byte
440 ;; scale - 1,2,4,8
441 ;; index - REX.x=0 [%rax %rcx %rdx %rbx none %rbp %rsi %rdi]
442 ;; REX.x=1 [%r8 %r9 %r10 %r11 %r12 %r13 %r14 %r15]
443 ;; base - REX.b=0 [%rax %rcx %rdx %rbx %rsp ** %rsi %rdi]
444 ;; REX.b=1 [%r8 %r9 %r10 %r11 %r12 ** %r14 %r15]
445 ;; where ** depends on modrm's mod field:
446 ;; mod=00 => disp32
447 ;; mod=01 => %rbp/%r13+disp8
448 ;; mod=10 => %rbp/%r13+disp32
449 (define (pack-sib scale index base)
450 (pack-byte233 (case scale [(#f 1) 0][(2) 1][(4) 2][(8) 3])
451 (or index 0)
452 (or base 0)))
453
454 ;; Modifiers
455 ;; A modifier is a closure that modifies code sequences of an instruction.
456 ;; It is called once in each pass per instruction. The first pass is
457 ;; used to determine the # of octets; there may be a label that's yet to
458 ;; be resolved. The second pass fills the resolved address.
459 ;;
460 ;; A modifier closure takes three arguments, s (spec), a (address) and
461 ;; t (table). S is an opaque list to which the modifier prepends
462 ;; information. T and A are #f in the first pass, and an alist of
463 ;; label to address and the address of the next instruction respectively
464 ;; in the second pass.
465
466 (define (opc c) (^[s a t] `(:opcode ,c ,@s)))
467 (define (opc+rq c r) (^[s a t] `(:opcode ,(+ c (modulo r 8)) ,@s)))
468
469 (define rex.w (^[s a t] `(:rex.w #t ,@s)))
470 (define (rex.b r) (^[s a t] (if (>= r 8) `(:rex.b #t ,@s) s)))
471
472 (define (reg r) (^[s a t] `(,@(if (>= r 8) `(:rex.r #t) '())
473 :reg ,r ,@s)))
474
475 (define (mem params)
476 (match params
477 [`(addr ,a) (mem-addr a)]
478 [`(base ,b) (mem-base b)]
479 [`(label ,l) (mem-label l)]
480 [`(base+disp ,b ,d) (mem-base+disp b d)]
481 [`(base+disp ,b label ,l) (mem-base+disp-label b l)]
482 [`(sib ,b ,i ,s ,d) (mem-sib b i s d)]))
483
484 (define (r/m-reg r)
485 (^[s a t] `(,@(if (>= r 8) `(:rex.b #t) '()) :mode 3 :r/m ,r ,@s)))
486
487 (define (mem-addr a)
488 (^[s a t] `(:mode 0 :r/m 4 :index 4 :base 5 :displacement ,(int8/32 a) ,@s)))
489
490 (define (mem-base b)
491 (^[s a t]
492 `(,@(if (>= b 8) `(:rex.b #t) '())
493 ,@(case (modulo b 8)
494 [(4) `(:mode 0 :r/m 4 :index 4 :base 4)] ; we need to use SIB
495 [(5) `(:mode 1 :r/m 5 :displacement (0))] ; we need to use disp8
496 [else `(:mode 0 :r/m ,b)] ; we can use mode0
497 )
498 ,@s)))
499
500 ;; we use RIP-relative addressing.
501 (define (mem-label l)
502 (^[s a t]
503 (if (and a t)
504 (let1 laddr (assq-ref t l)
505 (unless laddr (error "undefined label:" l))
506 `(:mode 0 :r/m 5 :displacement ,(int32 (- laddr a)) ,@s))
507 `(:mode 0 :r/m 5 :displacement ,(int32 0) ,@s))))
508
509 (define (mem-base+disp base disp)
510 (^[s a t]
511 `(,@(if (and (number? base) (>= base 8)) `(:rex.b #t) '())
512 :mode ,(if (number? base) (if (imm8? disp) 1 2) 0)
513 ,@(case base
514 [(%rip) `(:r/m 5 :displacement ,(int32 disp))]
515 [(4 12) `(:r/m base :index base :base base
516 :displacement ,(int8/32 disp))]
517 [else `(:r/m ,base :displacement ,(int8/32 disp))])
518 ,@s)))
519
520 (define (mem-base+disp-label base l)
521 (^[s a t]
522 (if (and a t)
523 (let1 laddr (assq-ref t l)
524 (unless laddr (error "undefined label:" l))
525 ((mem-base+disp base (- laddr a)) s a t))
526 ((mem-base+disp base 0) s a t))))
527
528 (define (mem-sib base index scale disp)
529 (when (= index 4)
530 (error "cannot use %rsp as an index register"))
531 (^[s a t]
532 `(,@(if (>= base 8) `(:rex.b #t) '())
533 ,@(if (>= index 8) `(:rex.x #t) '())
534 :mode ,(cond [(zero? disp) 0][(imm8? disp) 1][else 2])
535 :r/m 4 :scale ,scale :index ,index :base ,base
536 ,@(if (zero? disp) '() `(:displacement ,(int8/32 disp)))
537 ,@s)))
538
539 (define (imm8 i) (^[s a t] `(:immediate ,(int8 i) ,@s)))
540 (define (imm32 i) (^[s a t] `(:immediate ,(int32 i) ,@s)))
541 (define (imm64 i) (^[s a t] `(:immediate ,(int64 i) ,@s)))
542
543
544 (define *regs8* '(%al %cl %dl %bl %ah %ch %dh %bh))
545 (define *regs16* '(%ax %cx %dx %bx %sp %bp %si %di))
546 (define *regs32* '(%eax %ecx %edx %ebx %esp %ebp %esi %edi))
547 (define *regs64* '(%rax %rcx %rdx %rbx %rsp %rbp %rsi %rdi
548 %r8 %r9 %r10 %r11 %r12 %r13 %r14 %r15))
549
550 ;; reg8 - legacy general 8bit registers
551 (define (reg8? opr) (memq opr *regs8*))
552 (define (regnum8 reg) (find-index (cut eq? reg <>) *regs8*))
553
554 ;; reg64 - general 64bit registers. Can be source/dest registers.
555 ;; reg64b - registers that can be used as the 'base' register of modrm.
556 ;; this includes %rip plus reg64.
557 ;; regnum - arg must be reg64. returns the register number.
558 ;; regnumb - arg must be reg64b. returns register number or '%rip.
559
560 (define (reg64? opr) (memq opr *regs64*))
561 (define (reg64b? opr) (or (reg64? opr) (eq? opr '%rip)))
562 (define (regnum reg) (find-index (cut eq? reg <>) *regs64*))
563 (define (regnumb reg) (or (regnum reg) reg))
564
565 (define *regsse*
566 '(%xmm0 %xmm1 %xmm2 %xmm3 %xmm4 %xmm5 %xmm6 %xmm7))
567
568 ;; to pass to regset
569 (define-constant *x64-regvec* (list->vector (append *regs64* *regsse*)))
570
571 (define (regsse? opr) (memq opr *regsse*))
572 (define (ssenum reg) (find-index (cut eq? reg <>) *regsse*))
573
574 (define (scale? n) (memv n '(1 2 4 8)))
575
576 (define (imm64? opr) (and (integer? opr) (<= (- (expt 2 63)) opr (- (expt 2 63) 1))))
577 (define (imm32? opr) (and (integer? opr) (<= (- (expt 2 31)) opr (- (expt 2 31) 1))))
578 (define (imm8? opr) (and (integer? opr) (<= -128 opr 127)))
579
580
581 (define (int8 n)
582 `(,(logand n #xff)))
583
584 (define (int32 n)
585 (list (logand n #xff)
586 (logand (ash n -8) #xff)
587 (logand (ash n -16) #xff)
588 (logand (ash n -24) #xff)))
589
590 (define (int64 n)
591 (list (logand n #xff)
592 (logand (ash n -8) #xff)
593 (logand (ash n -16) #xff)
594 (logand (ash n -24) #xff)
595 (logand (ash n -32) #xff)
596 (logand (ash n -40) #xff)
597 (logand (ash n -48) #xff)
598 (logand (ash n -56) #xff)))
599
600 (define (int8/32 n) (if (<= -128 n 127) (int8 n) (int32 n)))