1 ;;;; miscellaneous VM definition noise for MIPS
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.
17 (eval-when (:compile-toplevel
:load-toplevel
:execute
)
18 (defvar *register-names
* (make-array 32 :initial-element nil
)))
20 (macrolet ((defreg (name offset
)
21 (let ((offset-sym (symbolicate name
"-OFFSET")))
22 `(eval-when (:compile-toplevel
:load-toplevel
:execute
)
23 (defconstant ,offset-sym
,offset
)
24 (setf (svref *register-names
* ,offset-sym
) ,(symbol-name name
)))))
26 (defregset (name &rest regs
)
27 `(eval-when (:compile-toplevel
:load-toplevel
:execute
)
29 (list ,@(mapcar #'(lambda (name) (symbolicate name
"-OFFSET")) regs
))))))
30 ;; Wired zero register.
31 (defreg zero
0) ; NULL
32 ;; Reserved for assembler use.
33 (defreg nl3
1) ; untagged temporary 3
34 ;; C return registers.
35 (defreg cfunc
2) ; FF function address, wastes a register
36 (defreg nl4
3) ; PA flag
37 ;; C argument registers.
38 (defreg nl0
4) ; untagged temporary 0
39 (defreg nl1
5) ; untagged temporary 1
40 (defreg nl2
6) ; untagged temporary 2
41 (defreg nargs
7) ; number of function arguments
42 ;; C unsaved temporaries.
43 (defreg a0
8) ; function arg 0
44 (defreg a1
9) ; function arg 1
45 (defreg a2
10) ; function arg 2
46 (defreg a3
11) ; function arg 3
47 (defreg a4
12) ; function arg 4
48 (defreg a5
13) ; function arg 5
50 (defreg lexenv
15) ; wastes a register
52 (defreg nfp
16) ; non-lisp frame pointer
53 (defreg ocfp
17) ; caller's control frame pointer
54 (defreg lra
18) ; tagged Lisp return address
55 (defreg l0
19) ; tagged temporary 0
56 (defreg null
20) ; NIL
57 (defreg bsp
21) ; binding stack pointer
58 (defreg cfp
22) ; control frame pointer
59 (defreg csp
23) ; control stack pointer
60 ;; More C unsaved temporaries.
61 (defreg l1
24) ; tagged temporary 1
62 (defreg alloc
25) ; ALLOC pointer
63 ;; 26 and 27 are used by the system kernel.
64 ;; 28 is the global pointer of our C runtime, and used for
65 ;; jump/branch relaxation in Lisp.
67 (defreg nsp
29) ; number (native) stack pointer
68 ;; C frame pointer, or additional saved register.
69 (defreg code
30) ; current function object
70 ;; Return link register.
71 (defreg lip
31) ; Lisp interior pointer
73 (defregset non-descriptor-regs
74 nl0 nl1 nl2 nl3 nl4 cfunc nargs nfp
)
76 (defregset descriptor-regs
77 a0 a1 a2 a3 a4 a5 fdefn lexenv ocfp lra l0 l1
)
79 (defregset *register-arg-offsets
*
82 (defregset reserve-descriptor-regs
85 (defregset reserve-non-descriptor-regs
89 ;;;; SB and SC definition:
91 (!define-storage-bases
92 (define-storage-base registers
:finite
:size
32)
93 (define-storage-base float-registers
:finite
:size
32)
94 (define-storage-base control-stack
:unbounded
:size
8)
95 (define-storage-base non-descriptor-stack
:unbounded
:size
0)
96 (define-storage-base constant
:non-packed
)
97 (define-storage-base immediate-constant
:non-packed
)
100 (!define-storage-classes
102 ;; Non-immediate constants in the constant pool
105 ;; Immediate constant.
106 (null immediate-constant
)
107 (zero immediate-constant
)
108 (immediate immediate-constant
)
112 ;; The control stack. (Scanned by GC)
113 (control-stack control-stack
)
115 ;; We put ANY-REG and DESCRIPTOR-REG early so that their SC-NUMBER
116 ;; is small and therefore the error trap information is smaller.
117 ;; Moving them up here from their previous place down below saves
118 ;; ~250K in core file size. --njf, 2006-01-27
120 ;; Immediate descriptor objects. Don't have to be seen by GC, but nothing
121 ;; bad will happen if they are. (fixnums, characters, header values, etc).
124 :locations
#.
(append non-descriptor-regs descriptor-regs
)
125 :reserve-locations
#.
(append reserve-non-descriptor-regs
126 reserve-descriptor-regs
)
127 :constant-scs
(constant zero immediate
)
129 :alternate-scs
(control-stack))
131 ;; Pointer descriptor objects. Must be seen by GC.
132 (descriptor-reg registers
133 :locations
#.descriptor-regs
134 :reserve-locations
#.reserve-descriptor-regs
135 :constant-scs
(constant null immediate
)
137 :alternate-scs
(control-stack))
139 ;; The non-descriptor stacks.
140 (signed-stack non-descriptor-stack
) ; (signed-byte 32)
141 (unsigned-stack non-descriptor-stack
) ; (unsigned-byte 32)
142 (character-stack non-descriptor-stack
) ; non-descriptor characters.
143 (sap-stack non-descriptor-stack
) ; System area pointers.
144 (single-stack non-descriptor-stack
) ; single-floats
145 (double-stack non-descriptor-stack
146 :element-size
2 :alignment
2) ; double floats.
147 ;; complex-single-floats
148 (complex-single-stack non-descriptor-stack
:element-size
2)
149 ;; complex-double-floats.
150 (complex-double-stack non-descriptor-stack
:element-size
4 :alignment
2)
153 ;; **** Things that can go in the integer registers.
155 ;; Non-Descriptor characters
156 (character-reg registers
157 :locations
#.non-descriptor-regs
158 :reserve-locations
#.reserve-non-descriptor-regs
159 :constant-scs
(immediate)
161 :alternate-scs
(character-stack))
163 ;; Non-Descriptor SAP's (arbitrary pointers into address space)
165 :locations
#.non-descriptor-regs
166 :reserve-locations
#.reserve-non-descriptor-regs
167 :constant-scs
(immediate)
169 :alternate-scs
(sap-stack))
171 ;; Non-Descriptor (signed or unsigned) numbers.
172 (signed-reg registers
173 :locations
#.non-descriptor-regs
174 :reserve-locations
#.reserve-non-descriptor-regs
175 :constant-scs
(zero immediate
)
177 :alternate-scs
(signed-stack))
178 (unsigned-reg registers
179 :locations
#.non-descriptor-regs
180 :reserve-locations
#.reserve-non-descriptor-regs
181 :constant-scs
(zero immediate
)
183 :alternate-scs
(unsigned-stack))
185 ;; Random objects that must not be seen by GC. Used only as temporaries.
186 (non-descriptor-reg registers
187 :locations
#.non-descriptor-regs
)
189 ;; Pointers to the interior of objects. Used only as an temporary.
190 (interior-reg registers
191 :locations
(#.lip-offset
))
194 ;; **** Things that can go in the floating point registers.
196 ;; Non-Descriptor single-floats.
197 (single-reg float-registers
198 :locations
(0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
199 :reserve-locations
(26 28 30)
202 :alternate-scs
(single-stack))
204 ;; Non-Descriptor double-floats.
205 (double-reg float-registers
206 :locations
(0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
207 :reserve-locations
(26 28 30)
208 ;; Note: we don't bother with the element size, 'cause nothing can be
209 ;; allocated in the odd fp regs anyway.
212 :alternate-scs
(double-stack))
214 (complex-single-reg float-registers
215 :locations
(0 4 8 12 16 20 24 28)
217 :reserve-locations
(24 28)
220 :alternate-scs
(complex-single-stack))
222 (complex-double-reg float-registers
223 :locations
(0 4 8 12 16 20 24 28)
225 :reserve-locations
(24 28)
228 :alternate-scs
(complex-double-stack))
230 (catch-block control-stack
:element-size catch-block-size
)
231 (unwind-block control-stack
:element-size unwind-block-size
)
233 ;; floating point numbers temporarily stuck in integer registers for c-call
234 (single-int-carg-reg registers
238 (double-int-carg-reg registers
242 :alignment
2 ;is this needed?
248 ;;;; Random TNs for interesting registers
250 (macrolet ((defregtn (name sc
)
251 (let ((offset-sym (symbolicate name
"-OFFSET"))
252 (tn-sym (symbolicate name
"-TN")))
253 `(defparameter ,tn-sym
254 (make-random-tn :kind
:normal
255 :sc
(sc-or-lose ',sc
)
256 :offset
,offset-sym
)))))
257 (defregtn zero any-reg
)
258 (defregtn nargs any-reg
)
260 (defregtn fdefn descriptor-reg
)
261 (defregtn lexenv descriptor-reg
)
263 (defregtn nfp any-reg
)
264 (defregtn ocfp any-reg
)
266 (defregtn null descriptor-reg
)
268 (defregtn bsp any-reg
)
269 (defregtn cfp any-reg
)
270 (defregtn csp any-reg
)
271 (defregtn alloc any-reg
)
272 (defregtn nsp any-reg
)
274 (defregtn code descriptor-reg
)
275 (defregtn lip interior-reg
))
277 ;;; If VALUE can be represented as an immediate constant, then return the
278 ;;; appropriate SC number, otherwise return NIL.
279 (defun immediate-constant-sc (value)
282 (sc-number-or-lose 'zero
))
284 (sc-number-or-lose 'null
))
286 (if (static-symbol-p value
)
287 (sc-number-or-lose 'immediate
)
289 ((or (integer #.sb
!xc
:most-negative-fixnum
#.sb
!xc
:most-positive-fixnum
)
291 (sc-number-or-lose 'immediate
))
292 #-sb-xc-host
; There is no such object type in the host
294 (sc-number-or-lose 'immediate
))
296 (sc-number-or-lose 'immediate
))))
298 (defun boxed-immediate-sc-p (sc)
299 (or (eql sc
(sc-number-or-lose 'zero
))
300 (eql sc
(sc-number-or-lose 'null
))
301 (eql sc
(sc-number-or-lose 'immediate
))))
303 ;;;; Function Call Parameters
305 ;;; The SC numbers for register and stack arguments/return values.
307 (defconstant immediate-arg-scn
(sc-number-or-lose 'any-reg
))
308 (defconstant control-stack-arg-scn
(sc-number-or-lose 'control-stack
))
310 (eval-when (:compile-toplevel
:load-toplevel
:execute
)
312 ;;; Offsets of special stack frame locations
313 (defconstant ocfp-save-offset
0)
314 (defconstant lra-save-offset
1)
315 (defconstant nfp-save-offset
2)
317 ;;; The number of arguments/return values passed in registers.
319 (defconstant register-arg-count
6)
321 ;;; The offsets within the register-arg SC that we pass values in, first
325 ;;; Names to use for the argument registers.
327 (defconstant-eqx register-arg-names
'(a0 a1 a2 a3 a4 a5
) #'equal
)
332 ;;; A list of TN's describing the register arguments.
334 (defparameter *register-arg-tns
*
335 (mapcar #'(lambda (n)
336 (make-random-tn :kind
:normal
337 :sc
(sc-or-lose 'descriptor-reg
)
339 *register-arg-offsets
*))
341 ;;; This is used by the debugger.
342 (defconstant single-value-return-byte-offset
8)
344 ;;; This function is called by debug output routines that want a pretty name
345 ;;; for a TN's location. It returns a thing that can be printed with PRINC.
346 (defun location-print-name (tn)
347 (declare (type tn tn
))
348 (let ((sb (sb-name (sc-sb (tn-sc tn
))))
349 (offset (tn-offset tn
)))
351 (registers (or (svref *register-names
* offset
)
352 (format nil
"R~D" offset
)))
353 (float-registers (format nil
"F~D" offset
))
354 (control-stack (format nil
"CS~D" offset
))
355 (non-descriptor-stack (format nil
"NS~D" offset
))
356 (constant (format nil
"Const~D" offset
))
357 (immediate-constant "Immed"))))
359 (defun combination-implementation-style (node)
360 (declare (type sb
!c
::combination node
) (ignore node
))
361 (values :default nil
))
363 (defun primitive-type-indirect-cell-type (ptype)
364 (declare (ignore ptype
))