| 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))) |