1 ;;;; miscellaneous VM definition noise for the x86
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 32))
20 (eval-when (:compile-toplevel :load-toplevel :execute)
21 (defvar *byte-register-names* (make-array 8 :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 *float-register-names* (make-array 8 :initial-element nil)))
26 (macrolet ((defreg (name offset size)
27 (let ((offset-sym (symbolicate name "-OFFSET"))
28 (names-vector (symbolicate "*" size "-REGISTER-NAMES*")))
30 (eval-when (:compile-toplevel :load-toplevel :execute)
31 ;; EVAL-WHEN is necessary because stuff like #.EAX-OFFSET
32 ;; (in the same file) depends on compile-time evaluation
33 ;; of the DEFCONSTANT. -- AL 20010224
34 (def!constant ,offset-sym ,offset))
35 (setf (svref ,names-vector ,offset-sym)
36 ,(symbol-name name)))))
37 ;; FIXME: It looks to me as though DEFREGSET should also
38 ;; define the related *FOO-REGISTER-NAMES* variable.
39 (defregset (name &rest regs)
40 `(eval-when (:compile-toplevel :load-toplevel :execute)
42 (list ,@(mapcar (lambda (name)
43 (symbolicate name "-OFFSET"))
48 ;; Note: the encoding here is different than that used by the chip.
49 ;; We use this encoding so that the compiler thinks that AX (and
50 ;; EAX) overlap AL and AH instead of AL and CL.
59 (defregset *byte-regs* al ah cl ch dl dh bl bh)
70 (defregset *word-regs* ax cx dx bx si di)
72 ;; double word registers
78 (defreg ebp 10 :dword)
79 (defreg esi 12 :dword)
80 (defreg edi 14 :dword)
81 (defregset *dword-regs* eax ecx edx ebx esi edi)
83 ;; floating point registers
92 (defregset *float-regs* fr0 fr1 fr2 fr3 fr4 fr5 fr6 fr7)
94 ;; registers used to pass arguments
96 ;; the number of arguments/return values passed in registers
97 (def!constant register-arg-count 3)
98 ;; names and offsets for registers used to pass arguments
99 (eval-when (:compile-toplevel :load-toplevel :execute)
100 (defparameter *register-arg-names* '(edx edi esi)))
101 (defregset *register-arg-offsets* edx edi esi))
105 ;;; Despite the fact that there are only 8 different registers, we consider
106 ;;; them 16 in order to describe the overlap of byte registers. The only
107 ;;; thing we need to represent is what registers overlap. Therefore, we
108 ;;; consider bytes to take one unit, and words or dwords to take two. We
109 ;;; don't need to tell the difference between words and dwords, because
110 ;;; you can't put two words in a dword register.
111 (define-storage-base registers :finite :size 16)
113 ;;; jrd changed this from size 1 to size 8. It doesn't seem to make much
114 ;;; sense to use the 387's idea of a stack; 8 separate registers is easier
117 ;;; (define-storage-base float-registers :finite :size 1)
119 (define-storage-base float-registers :finite :size 8)
121 (define-storage-base stack :unbounded :size 8)
122 (define-storage-base constant :non-packed)
123 (define-storage-base immediate-constant :non-packed)
124 (define-storage-base noise :unbounded :size 2)
128 ;;; a handy macro so we don't have to keep changing all the numbers whenever
129 ;;; we insert a new storage class
131 (defmacro !define-storage-classes (&rest classes)
134 (dolist (class classes)
135 (let* ((sc-name (car class))
136 (constant-name (symbolicate sc-name "-SC-NUMBER")))
137 (forms `(define-storage-class ,sc-name ,index
139 (forms `(def!constant ,constant-name ,index))
144 ;;; The DEFINE-STORAGE-CLASS call for CATCH-BLOCK refers to the size
145 ;;; of CATCH-BLOCK. The size of CATCH-BLOCK isn't calculated until
146 ;;; later in the build process, and the calculation is entangled with
147 ;;; code which has lots of predependencies, including dependencies on
148 ;;; the prior call of DEFINE-STORAGE-CLASS. The proper way to
149 ;;; unscramble this would be to untangle the code, so that the code
150 ;;; which calculates the size of CATCH-BLOCK can be separated from the
151 ;;; other lots-of-dependencies code, so that the code which calculates
152 ;;; the size of CATCH-BLOCK can be executed early, so that this value
153 ;;; is known properly at this point in compilation. However, that
154 ;;; would be a lot of editing of code that I (WHN 19990131) can't test
155 ;;; until the project is complete. So instead, I set the correct value
156 ;;; by hand here (a sort of nondeterministic guess of the right
157 ;;; answer:-) and add an assertion later, after the value is
158 ;;; calculated, that the original guess was correct.
160 ;;; (What a KLUDGE! Anyone who wants to come in and clean up this mess
161 ;;; has my gratitude.) (FIXME: Maybe this should be me..)
162 (eval-when (:compile-toplevel :load-toplevel :execute)
163 (def!constant kludge-nondeterministic-catch-block-size
164 #!-win32 5 #!+win32 7))
166 (!define-storage-classes
168 ;; non-immediate constants in the constant pool
171 ;; some FP constants can be generated in the i387 silicon
172 (fp-constant immediate-constant)
174 (immediate immediate-constant)
181 (control-stack stack) ; may be pointers, scanned by GC
183 ;; the non-descriptor stacks
184 (signed-stack stack) ; (signed-byte 32)
185 (unsigned-stack stack) ; (unsigned-byte 32)
186 (character-stack stack) ; non-descriptor characters.
187 (sap-stack stack) ; System area pointers.
188 (single-stack stack) ; single-floats
189 (double-stack stack :element-size 2) ; double-floats.
191 (long-stack stack :element-size 3) ; long-floats.
192 (complex-single-stack stack :element-size 2) ; complex-single-floats
193 (complex-double-stack stack :element-size 4) ; complex-double-floats
195 (complex-long-stack stack :element-size 6) ; complex-long-floats
204 ;; things that can go in the integer registers
207 ;; On the X86, we don't have to distinguish between descriptor and
208 ;; non-descriptor registers, because of the conservative GC.
209 ;; Therefore, we use different scs only to distinguish between
210 ;; descriptor and non-descriptor values and to specify size.
212 ;; immediate descriptor objects. Don't have to be seen by GC, but nothing
213 ;; bad will happen if they are. (fixnums, characters, header values, etc).
215 :locations #.*dword-regs*
217 ; :reserve-locations (#.eax-offset)
218 :constant-scs (immediate)
220 :alternate-scs (control-stack))
222 ;; pointer descriptor objects -- must be seen by GC
223 (descriptor-reg registers
224 :locations #.*dword-regs*
226 ; :reserve-locations (#.eax-offset)
227 :constant-scs (constant immediate)
229 :alternate-scs (control-stack))
231 ;; non-descriptor characters
232 (character-reg registers
233 :locations #!-sb-unicode #.*byte-regs*
234 #!+sb-unicode #.*dword-regs*
235 #!+sb-unicode #!+sb-unicode
237 #!-sb-unicode #!-sb-unicode
238 :reserve-locations (#.ah-offset #.al-offset)
239 :constant-scs (immediate)
241 :alternate-scs (character-stack))
243 ;; non-descriptor SAPs (arbitrary pointers into address space)
245 :locations #.*dword-regs*
247 ; :reserve-locations (#.eax-offset)
248 :constant-scs (immediate)
250 :alternate-scs (sap-stack))
252 ;; non-descriptor (signed or unsigned) numbers
253 (signed-reg registers
254 :locations #.*dword-regs*
256 ; :reserve-locations (#.eax-offset)
257 :constant-scs (immediate)
259 :alternate-scs (signed-stack))
260 (unsigned-reg registers
261 :locations #.*dword-regs*
263 ; :reserve-locations (#.eax-offset)
264 :constant-scs (immediate)
266 :alternate-scs (unsigned-stack))
268 ;; miscellaneous objects that must not be seen by GC. Used only as
271 :locations #.*word-regs*
273 ; :reserve-locations (#.ax-offset)
276 :locations #.*byte-regs*
277 ; :reserve-locations (#.al-offset #.ah-offset)
280 ;; that can go in the floating point registers
282 ;; non-descriptor SINGLE-FLOATs
283 (single-reg float-registers
284 :locations (0 1 2 3 4 5 6 7)
285 :constant-scs (fp-constant)
287 :alternate-scs (single-stack))
289 ;; non-descriptor DOUBLE-FLOATs
290 (double-reg float-registers
291 :locations (0 1 2 3 4 5 6 7)
292 :constant-scs (fp-constant)
294 :alternate-scs (double-stack))
296 ;; non-descriptor LONG-FLOATs
298 (long-reg float-registers
299 :locations (0 1 2 3 4 5 6 7)
300 :constant-scs (fp-constant)
302 :alternate-scs (long-stack))
304 (complex-single-reg float-registers
309 :alternate-scs (complex-single-stack))
311 (complex-double-reg float-registers
316 :alternate-scs (complex-double-stack))
319 (complex-long-reg float-registers
324 :alternate-scs (complex-long-stack))
326 ;; a catch or unwind block
327 (catch-block stack :element-size kludge-nondeterministic-catch-block-size))
329 (eval-when (:compile-toplevel :load-toplevel :execute)
330 (defparameter *byte-sc-names*
331 '(#!-sb-unicode character-reg byte-reg #!-sb-unicode character-stack))
332 (defparameter *word-sc-names* '(word-reg))
333 (defparameter *dword-sc-names*
334 '(any-reg descriptor-reg sap-reg signed-reg unsigned-reg control-stack
335 signed-stack unsigned-stack sap-stack single-stack
336 #!+sb-unicode character-reg #!+sb-unicode character-stack constant))
337 ;;; added by jrd. I guess the right thing to do is to treat floats
338 ;;; as a separate size...
340 ;;; These are used to (at least) determine operand size.
341 (defparameter *float-sc-names* '(single-reg))
342 (defparameter *double-sc-names* '(double-reg double-stack))
345 ;;;; miscellaneous TNs for the various registers
347 (macrolet ((def-misc-reg-tns (sc-name &rest reg-names)
349 (dolist (reg-name reg-names)
350 (let ((tn-name (symbolicate reg-name "-TN"))
351 (offset-name (symbolicate reg-name "-OFFSET")))
352 ;; FIXME: It'd be good to have the special
353 ;; variables here be named with the *FOO*
355 (forms `(defparameter ,tn-name
356 (make-random-tn :kind :normal
357 :sc (sc-or-lose ',sc-name)
360 `(progn ,@(forms)))))
362 (def-misc-reg-tns unsigned-reg eax ebx ecx edx ebp esp edi esi)
363 (def-misc-reg-tns word-reg ax bx cx dx bp sp di si)
364 (def-misc-reg-tns byte-reg al ah bl bh cl ch dl dh)
365 (def-misc-reg-tns single-reg fr0 fr1 fr2 fr3 fr4 fr5 fr6 fr7))
367 ;;; TNs for registers used to pass arguments
368 (defparameter *register-arg-tns*
369 (mapcar (lambda (register-arg-name)
370 (symbol-value (symbolicate register-arg-name "-TN")))
371 *register-arg-names*))
373 ;;; FIXME: doesn't seem to be used in SBCL
376 (defparameter fp-constant-tn
377 (make-random-tn :kind :normal
378 :sc (sc-or-lose 'fp-constant)
379 :offset 31)) ; Offset doesn't get used.
382 ;;; If value can be represented as an immediate constant, then return
383 ;;; the appropriate SC number, otherwise return NIL.
384 (!def-vm-support-routine immediate-constant-sc (value)
386 ((or (integer #.sb!xc:most-negative-fixnum #.sb!xc:most-positive-fixnum)
388 (sc-number-or-lose 'immediate))
390 (when (static-symbol-p value)
391 (sc-number-or-lose 'immediate)))
393 (when (or (eql value 0f0) (eql value 1f0))
394 (sc-number-or-lose 'fp-constant)))
396 (when (or (eql value 0d0) (eql value 1d0))
397 (sc-number-or-lose 'fp-constant)))
400 (when (or (eql value 0l0) (eql value 1l0)
402 (eql value (log 10l0 2l0))
403 (eql value (log 2.718281828459045235360287471352662L0 2l0))
404 (eql value (log 2l0 10l0))
405 (eql value (log 2l0 2.718281828459045235360287471352662L0)))
406 (sc-number-or-lose 'fp-constant)))))
408 ;; For an immediate TN, return its value encoded for use as a literal.
409 ;; For any other TN, return the TN. Only works for FIXNUMs,
410 ;; STATIC-SYMBOLs, and CHARACTERS (FLOATs and SAPs are handled
412 (defun encode-value-if-immediate (tn)
413 (if (sc-is tn immediate)
414 (let ((val (tn-value tn)))
416 (integer (fixnumize val))
417 (symbol (+ nil-value (static-symbol-offset val)))
418 (character (logior (ash (char-code val) n-widetag-bits)
419 character-widetag))))
422 ;;;; miscellaneous function call parameters
424 ;;; Offsets of special stack frame locations relative to EBP.
426 ;;; Consider the standard prologue PUSH EBP; MOV EBP, ESP: the return
427 ;;; address is at EBP+4, the old control stack frame pointer is at
428 ;;; EBP, the magic 3rd slot is at EBP-4. Then come the locals from
430 (def!constant return-pc-save-offset 0)
431 (def!constant ocfp-save-offset 1)
432 ;;; Let SP be the stack pointer before CALLing, and FP is the frame
433 ;;; pointer after the standard prologue. SP +
434 ;;; FRAME-WORD-OFFSET(SP->FP-OFFSET + I) = FP + FRAME-WORD-OFFSET(I).
435 (def!constant sp->fp-offset 2)
437 (declaim (inline frame-word-offset))
438 (defun frame-word-offset (index)
441 (declaim (inline frame-byte-offset))
442 (defun frame-byte-offset (index)
443 (* (frame-word-offset index) n-word-bytes))
445 ;;; FIXME: This is a bad comment (changed since when?) and there are others
446 ;;; like it in this file. It'd be nice to clarify them. Failing that deleting
447 ;;; them or flagging them with KLUDGE might be better than nothing.
449 ;;; names of these things seem to have changed. these aliases by jrd
450 (def!constant lra-save-offset return-pc-save-offset)
452 (def!constant cfp-offset ebp-offset) ; pfw - needed by stuff in /code
453 ; related to signal context stuff
455 ;;; This is used by the debugger.
456 (def!constant single-value-return-byte-offset 2)
458 ;;; This function is called by debug output routines that want a pretty name
459 ;;; for a TN's location. It returns a thing that can be printed with PRINC.
460 (!def-vm-support-routine location-print-name (tn)
461 (declare (type tn tn))
462 (let* ((sc (tn-sc tn))
463 (sb (sb-name (sc-sb sc)))
464 (offset (tn-offset tn)))
467 (let* ((sc-name (sc-name sc))
468 (name-vec (cond ((member sc-name *byte-sc-names*)
469 *byte-register-names*)
470 ((member sc-name *word-sc-names*)
471 *word-register-names*)
472 ((member sc-name *dword-sc-names*)
473 *dword-register-names*))))
475 (< -1 offset (length name-vec))
476 (svref name-vec offset))
477 ;; FIXME: Shouldn't this be an ERROR?
478 (format nil "<unknown reg: off=~W, sc=~A>" offset sc-name))))
479 (float-registers (format nil "FR~D" offset))
480 (stack (format nil "S~D" offset))
481 (constant (format nil "Const~D" offset))
482 (immediate-constant "Immed")
483 (noise (symbol-name (sc-name sc))))))
484 ;;; FIXME: Could this, and everything that uses it, be made #!+SB-SHOW?
486 (!def-vm-support-routine combination-implementation-style (node)
487 (declare (type sb!c::combination node))
488 (flet ((valid-funtype (args result)
489 (sb!c::valid-fun-use node
490 (sb!c::specifier-type
491 `(function ,args ,result)))))
492 (case (sb!c::combination-fun-source-name node)
495 ((valid-funtype '(fixnum fixnum) '*)
496 (values :direct nil))
497 ((valid-funtype '((signed-byte 32) (signed-byte 32)) '*)
498 (values :direct nil))
499 ((valid-funtype '((unsigned-byte 32) (unsigned-byte 32)) '*)
500 (values :direct nil))
501 (t (values :default nil))))
504 ((and (valid-funtype '((integer 0 29) fixnum) '*)
505 (sb!c::constant-lvar-p (first (sb!c::basic-combination-args node))))
506 (values :transform '(lambda (index integer)
507 (%logbitp integer index))))
508 ((valid-funtype '((integer 0 31) (signed-byte 32)) '*)
509 (values :transform '(lambda (index integer)
510 (%logbitp integer index))))
511 ((valid-funtype '((integer 0 31) (unsigned-byte 32)) '*)
512 (values :transform '(lambda (index integer)
513 (%logbitp integer index))))
514 (t (values :default nil))))
515 (t (values :default nil)))))