1 ;;;; miscellaneous VM definition noise for the x86-64
3 ;;;; This software is part of the SBCL system. See the README file for
6 ;;;; This software is derived from the CMU CL system, which was
7 ;;;; written at Carnegie Mellon University and released into the
8 ;;;; public domain. The software is in the public domain and is
9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
10 ;;;; files for more information.
14 ;;; the size of an INTEGER representation of a SYSTEM-AREA-POINTER, i.e.
15 ;;; size of a native memory address
16 (deftype sap-int () '(unsigned-byte 64))
20 (eval-when (:compile-toplevel :load-toplevel :execute)
21 (defvar *byte-register-names* (make-array 32 :initial-element nil))
22 (defvar *word-register-names* (make-array 16 :initial-element nil))
23 (defvar *dword-register-names* (make-array 16 :initial-element nil))
24 (defvar *qword-register-names* (make-array 32 :initial-element nil))
25 (defvar *float-register-names* (make-array 16 :initial-element nil)))
27 (macrolet ((defreg (name offset size)
28 (let ((offset-sym (symbolicate name "-OFFSET"))
29 (names-vector (symbolicate "*" size "-REGISTER-NAMES*")))
31 (eval-when (:compile-toplevel :load-toplevel :execute)
32 ;; EVAL-WHEN is necessary because stuff like #.EAX-OFFSET
33 ;; (in the same file) depends on compile-time evaluation
34 ;; of the DEFCONSTANT. -- AL 20010224
35 (def!constant ,offset-sym ,offset))
36 (setf (svref ,names-vector ,offset-sym)
37 ,(symbol-name name)))))
38 ;; FIXME: It looks to me as though DEFREGSET should also
39 ;; define the related *FOO-REGISTER-NAMES* variable.
40 (defregset (name &rest regs)
41 `(eval-when (:compile-toplevel :load-toplevel :execute)
43 (list ,@(mapcar (lambda (name)
44 (symbolicate name "-OFFSET"))
49 ;; Note: the encoding here is different than that used by the chip.
50 ;; We use this encoding so that the compiler thinks that AX (and
51 ;; EAX) overlap AL and AH instead of AL and CL.
53 ;; High-byte are registers disabled on AMD64, since they can't be
54 ;; encoded for an op that has a REX-prefix and we don't want to
55 ;; add special cases into the code generation. The overlap doesn't
56 ;; therefore exist anymore, but the numbering hasn't been changed
66 (defreg r10b 20 :byte)
67 (defreg r11b 22 :byte)
68 (defreg r12b 24 :byte)
69 (defreg r13b 26 :byte)
70 (defreg r14b 28 :byte)
71 (defreg r15b 30 :byte)
72 (defregset *byte-regs*
73 al cl dl bl sil dil r8b r9b r10b
74 #+nil r11b #+nil r12b r13b r14b r15b)
85 (defregset *word-regs* ax cx dx bx si di)
87 ;; double word registers
93 (defreg ebp 10 :dword)
94 (defreg esi 12 :dword)
95 (defreg edi 14 :dword)
96 (defregset *dword-regs* eax ecx edx ebx esi edi)
100 (defreg rcx 2 :qword)
101 (defreg rdx 4 :qword)
102 (defreg rbx 6 :qword)
103 (defreg rsp 8 :qword)
104 (defreg rbp 10 :qword)
105 (defreg rsi 12 :qword)
106 (defreg rdi 14 :qword)
107 (defreg r8 16 :qword)
108 (defreg r9 18 :qword)
109 (defreg r10 20 :qword)
110 (defreg r11 22 :qword)
111 (defreg r12 24 :qword)
112 (defreg r13 26 :qword)
113 (defreg r14 28 :qword)
114 (defreg r15 30 :qword)
115 ;; for no good reason at the time, r12 and r13 were missed from the
116 ;; list of qword registers. However
117 ;; <jsnell> r13 is already used as temporary [#lisp irc 2005/01/30]
118 ;; and we're now going to use r12 for the struct thread*
120 ;; Except that now we use r11 instead of r13 as the temporary,
121 ;; since it's got a more compact encoding than r13, and experimentally
122 ;; the temporary gets used more than the other registers that are never
123 ;; wired. -- JES, 2005-11-02
124 (defregset *qword-regs* rax rcx rdx rbx rsi rdi
125 r8 r9 r10 #+nil r11 #+nil r12 r13 r14 r15)
127 ;; floating point registers
128 (defreg float0 0 :float)
129 (defreg float1 1 :float)
130 (defreg float2 2 :float)
131 (defreg float3 3 :float)
132 (defreg float4 4 :float)
133 (defreg float5 5 :float)
134 (defreg float6 6 :float)
135 (defreg float7 7 :float)
136 (defreg float8 8 :float)
137 (defreg float9 9 :float)
138 (defreg float10 10 :float)
139 (defreg float11 11 :float)
140 (defreg float12 12 :float)
141 (defreg float13 13 :float)
142 (defreg float14 14 :float)
143 (defreg float15 15 :float)
144 (defregset *float-regs* float0 float1 float2 float3 float4 float5 float6 float7
145 float8 float9 float10 float11 float12 float13 float14 float15)
147 ;; registers used to pass arguments
149 ;; the number of arguments/return values passed in registers
150 (def!constant register-arg-count 3)
151 ;; names and offsets for registers used to pass arguments
152 (eval-when (:compile-toplevel :load-toplevel :execute)
153 (defparameter *register-arg-names* '(rdx rdi rsi)))
154 (defregset *register-arg-offsets* rdx rdi rsi)
155 (defregset *c-call-register-arg-offsets* rdi rsi rdx rcx r8 r9))
159 ;;; There are 16 registers really, but we consider them 32 in order to
160 ;;; describe the overlap of byte registers. The only thing we need to
161 ;;; represent is what registers overlap. Therefore, we consider bytes
162 ;;; to take one unit, and [dq]?words to take two. We don't need to
163 ;;; tell the difference between [dq]?words, because you can't put two
164 ;;; words in a dword register.
165 (define-storage-base registers :finite :size 32)
167 (define-storage-base float-registers :finite :size 16)
169 (define-storage-base stack :unbounded :size 8)
170 (define-storage-base constant :non-packed)
171 (define-storage-base immediate-constant :non-packed)
172 (define-storage-base noise :unbounded :size 2)
176 ;;; a handy macro so we don't have to keep changing all the numbers whenever
177 ;;; we insert a new storage class
179 (defmacro !define-storage-classes (&rest classes)
182 (dolist (class classes)
183 (let* ((sc-name (car class))
184 (constant-name (symbolicate sc-name "-SC-NUMBER")))
185 (forms `(define-storage-class ,sc-name ,index
187 (forms `(def!constant ,constant-name ,index))
192 ;;; The DEFINE-STORAGE-CLASS call for CATCH-BLOCK refers to the size
193 ;;; of CATCH-BLOCK. The size of CATCH-BLOCK isn't calculated until
194 ;;; later in the build process, and the calculation is entangled with
195 ;;; code which has lots of predependencies, including dependencies on
196 ;;; the prior call of DEFINE-STORAGE-CLASS. The proper way to
197 ;;; unscramble this would be to untangle the code, so that the code
198 ;;; which calculates the size of CATCH-BLOCK can be separated from the
199 ;;; other lots-of-dependencies code, so that the code which calculates
200 ;;; the size of CATCH-BLOCK can be executed early, so that this value
201 ;;; is known properly at this point in compilation. However, that
202 ;;; would be a lot of editing of code that I (WHN 19990131) can't test
203 ;;; until the project is complete. So instead, I set the correct value
204 ;;; by hand here (a sort of nondeterministic guess of the right
205 ;;; answer:-) and add an assertion later, after the value is
206 ;;; calculated, that the original guess was correct.
208 ;;; (What a KLUDGE! Anyone who wants to come in and clean up this mess
209 ;;; has my gratitude.) (FIXME: Maybe this should be me..)
210 (eval-when (:compile-toplevel :load-toplevel :execute)
211 (def!constant kludge-nondeterministic-catch-block-size 5))
213 (!define-storage-classes
215 ;; non-immediate constants in the constant pool
218 (fp-single-zero immediate-constant)
219 (fp-double-zero immediate-constant)
220 (fp-complex-single-zero immediate-constant)
221 (fp-complex-double-zero immediate-constant)
223 (fp-single-immediate immediate-constant)
224 (fp-double-immediate immediate-constant)
225 (fp-complex-single-immediate immediate-constant)
226 (fp-complex-double-immediate immediate-constant)
228 (immediate immediate-constant)
235 (control-stack stack) ; may be pointers, scanned by GC
237 ;; the non-descriptor stacks
238 ;; XXX alpha backend has :element-size 2 :alignment 2 in these entries
239 (signed-stack stack) ; (signed-byte 64)
240 (unsigned-stack stack) ; (unsigned-byte 64)
241 (character-stack stack) ; non-descriptor characters.
242 (sap-stack stack) ; System area pointers.
243 (single-stack stack) ; single-floats
245 (complex-single-stack stack) ; complex-single-floats
246 (complex-double-stack stack :element-size 2) ; complex-double-floats
256 ;; things that can go in the integer registers
259 ;; On the X86, we don't have to distinguish between descriptor and
260 ;; non-descriptor registers, because of the conservative GC.
261 ;; Therefore, we use different scs only to distinguish between
262 ;; descriptor and non-descriptor values and to specify size.
264 ;; immediate descriptor objects. Don't have to be seen by GC, but nothing
265 ;; bad will happen if they are. (fixnums, characters, header values, etc).
267 :locations #.*qword-regs*
268 :element-size 2 ; I think this is for the al/ah overlap thing
269 :constant-scs (immediate)
271 :alternate-scs (control-stack))
273 ;; pointer descriptor objects -- must be seen by GC
274 (descriptor-reg registers
275 :locations #.*qword-regs*
277 ; :reserve-locations (#.eax-offset)
278 :constant-scs (constant immediate)
280 :alternate-scs (control-stack))
282 ;; non-descriptor characters
283 (character-reg registers
284 :locations #!-sb-unicode #.*byte-regs*
285 #!+sb-unicode #.*qword-regs*
286 #!+sb-unicode #!+sb-unicode
288 #!-sb-unicode #!-sb-unicode
289 :reserve-locations (#.al-offset)
290 :constant-scs (immediate)
292 :alternate-scs (character-stack))
294 ;; non-descriptor SAPs (arbitrary pointers into address space)
296 :locations #.*qword-regs*
298 ; :reserve-locations (#.eax-offset)
299 :constant-scs (immediate)
301 :alternate-scs (sap-stack))
303 ;; non-descriptor (signed or unsigned) numbers
304 (signed-reg registers
305 :locations #.*qword-regs*
307 :constant-scs (immediate)
309 :alternate-scs (signed-stack))
310 (unsigned-reg registers
311 :locations #.*qword-regs*
313 :constant-scs (immediate)
315 :alternate-scs (unsigned-stack))
317 ;; miscellaneous objects that must not be seen by GC. Used only as
320 :locations #.*word-regs*
324 :locations #.*dword-regs*
328 :locations #.*byte-regs*
331 ;; that can go in the floating point registers
333 ;; non-descriptor SINGLE-FLOATs
334 (single-reg float-registers
335 :locations #.*float-regs*
336 :constant-scs (fp-single-zero fp-single-immediate)
338 :alternate-scs (single-stack))
340 ;; non-descriptor DOUBLE-FLOATs
341 (double-reg float-registers
342 :locations #.*float-regs*
343 :constant-scs (fp-double-zero fp-double-immediate)
345 :alternate-scs (double-stack))
347 (complex-single-reg float-registers
348 :locations #.*float-regs*
349 :constant-scs (fp-complex-single-zero fp-complex-single-immediate)
351 :alternate-scs (complex-single-stack))
353 (complex-double-reg float-registers
354 :locations #.*float-regs*
355 :constant-scs (fp-complex-double-zero fp-complex-double-immediate)
357 :alternate-scs (complex-double-stack))
359 ;; a catch or unwind block
360 (catch-block stack :element-size kludge-nondeterministic-catch-block-size))
362 (eval-when (:compile-toplevel :load-toplevel :execute)
363 (defparameter *byte-sc-names*
364 '(#!-sb-unicode character-reg byte-reg #!-sb-unicode character-stack))
365 (defparameter *word-sc-names* '(word-reg))
366 (defparameter *dword-sc-names* '(dword-reg))
367 (defparameter *qword-sc-names*
368 '(any-reg descriptor-reg sap-reg signed-reg unsigned-reg control-stack
369 signed-stack unsigned-stack sap-stack single-stack
370 #!+sb-unicode character-reg #!+sb-unicode character-stack constant))
371 ;;; added by jrd. I guess the right thing to do is to treat floats
372 ;;; as a separate size...
374 ;;; These are used to (at least) determine operand size.
375 (defparameter *float-sc-names* '(single-reg))
376 (defparameter *double-sc-names* '(double-reg double-stack))
377 (defparameter *complex-sc-names* '(complex-single-reg complex-single-stack
378 complex-double-reg complex-double-stack))
381 ;;;; miscellaneous TNs for the various registers
383 (macrolet ((def-misc-reg-tns (sc-name &rest reg-names)
385 (dolist (reg-name reg-names)
386 (let ((tn-name (symbolicate reg-name "-TN"))
387 (offset-name (symbolicate reg-name "-OFFSET")))
388 ;; FIXME: It'd be good to have the special
389 ;; variables here be named with the *FOO*
391 (forms `(defparameter ,tn-name
392 (make-random-tn :kind :normal
393 :sc (sc-or-lose ',sc-name)
396 `(progn ,@(forms)))))
398 (def-misc-reg-tns unsigned-reg rax rbx rcx rdx rbp rsp rdi rsi
399 r8 r9 r10 r11 r12 r13 r14 r15)
400 (def-misc-reg-tns dword-reg eax ebx ecx edx ebp esp edi esi)
401 (def-misc-reg-tns word-reg ax bx cx dx bp sp di si)
402 (def-misc-reg-tns byte-reg al cl dl bl sil dil r8b r9b r10b
403 r11b r12b r13b r14b r15b)
404 (def-misc-reg-tns single-reg
405 float0 float1 float2 float3 float4 float5 float6 float7
406 float8 float9 float10 float11 float12 float13 float14 float15))
408 ;; A register that's never used by the code generator, and can therefore
409 ;; be used as an assembly temporary in cases where a VOP :TEMPORARY can't
411 (defparameter temp-reg-tn r11-tn)
413 ;;; TNs for registers used to pass arguments
414 (defparameter *register-arg-tns*
415 (mapcar (lambda (register-arg-name)
416 (symbol-value (symbolicate register-arg-name "-TN")))
417 *register-arg-names*))
419 (defparameter thread-base-tn
420 (make-random-tn :kind :normal :sc (sc-or-lose 'unsigned-reg )
423 ;;; If value can be represented as an immediate constant, then return
424 ;;; the appropriate SC number, otherwise return NIL.
425 (!def-vm-support-routine immediate-constant-sc (value)
427 ((or (integer #.sb!xc:most-negative-fixnum #.sb!xc:most-positive-fixnum)
429 (sc-number-or-lose 'immediate))
431 (when (static-symbol-p value)
432 (sc-number-or-lose 'immediate)))
435 (if (eql value 0f0) 'fp-single-zero 'fp-single-immediate)))
438 (if (eql value 0d0) 'fp-double-zero 'fp-double-immediate)))
439 ((complex single-float)
441 (if (eql value #c(0f0 0f0))
442 'fp-complex-single-zero
443 'fp-complex-single-immediate)))
444 ((complex double-float)
446 (if (eql value #c(0d0 0d0))
447 'fp-complex-double-zero
448 'fp-complex-double-immediate)))))
451 ;;;; miscellaneous function call parameters
453 ;;; Offsets of special stack frame locations relative to RBP.
455 ;;; Consider the standard prologue PUSH RBP; MOV RBP, RSP: the return
456 ;;; address is at RBP+8, the old control stack frame pointer is at
457 ;;; RBP, the magic 3rd slot is at RBP-8. Then come the locals from
459 (def!constant return-pc-save-offset 0)
460 (def!constant ocfp-save-offset 1)
461 (def!constant code-save-offset 2)
462 ;;; Let SP be the stack pointer before CALLing, and FP is the frame
463 ;;; pointer after the standard prologue. SP +
464 ;;; FRAME-WORD-OFFSET(SP->FP-OFFSET + I) = FP + FRAME-WORD-OFFSET(I).
465 (def!constant sp->fp-offset 2)
467 (declaim (inline frame-word-offset))
468 (defun frame-word-offset (index)
471 (declaim (inline frame-byte-offset))
472 (defun frame-byte-offset (index)
473 (* (frame-word-offset index) n-word-bytes))
475 (def!constant lra-save-offset return-pc-save-offset) ; ?
477 ;;; This is used by the debugger.
478 (def!constant single-value-return-byte-offset 3)
480 ;;; This function is called by debug output routines that want a pretty name
481 ;;; for a TN's location. It returns a thing that can be printed with PRINC.
482 (!def-vm-support-routine location-print-name (tn)
483 (declare (type tn tn))
484 (let* ((sc (tn-sc tn))
485 (sb (sb-name (sc-sb sc)))
486 (offset (tn-offset tn)))
489 (let* ((sc-name (sc-name sc))
490 (name-vec (cond ((member sc-name *byte-sc-names*)
491 *byte-register-names*)
492 ((member sc-name *word-sc-names*)
493 *word-register-names*)
494 ((member sc-name *dword-sc-names*)
495 *dword-register-names*)
496 ((member sc-name *qword-sc-names*)
497 *qword-register-names*))))
499 (< -1 offset (length name-vec))
500 (svref name-vec offset))
501 ;; FIXME: Shouldn't this be an ERROR?
502 (format nil "<unknown reg: off=~W, sc=~A>" offset sc-name))))
503 (float-registers (format nil "FLOAT~D" offset))
504 (stack (format nil "S~D" offset))
505 (constant (format nil "Const~D" offset))
506 (immediate-constant "Immed")
507 (noise (symbol-name (sc-name sc))))))
508 ;;; FIXME: Could this, and everything that uses it, be made #!+SB-SHOW?
510 (defun dwords-for-quad (value)
511 (let* ((lo (logand value (1- (ash 1 32))))
512 (hi (ash value -32)))
515 (defun words-for-dword (value)
516 (let* ((lo (logand value (1- (ash 1 16))))
517 (hi (ash value -16)))
520 (def!constant cfp-offset rbp-offset) ; pfw - needed by stuff in /code
522 (!def-vm-support-routine combination-implementation-style (node)
523 (declare (type sb!c::combination node) (ignore node))
524 (values :default nil))