1 ;;; Written by Rob MacLachlan.
2 ;;; SPARC conversion by William Lott.
7 (define-move-fun (load-immediate 1) (vop x y)
9 (any-reg descriptor-reg))
10 (let ((val (tn-value x)))
13 (inst lr y (fixnumize val)))
19 (inst lr y (logior (ash (char-code val) n-widetag-bits)
20 base-char-widetag))))))
22 (define-move-fun (load-number 1) (vop x y)
24 (signed-reg unsigned-reg))
25 (inst lr y (tn-value x)))
27 (define-move-fun (load-base-char 1) (vop x y)
28 ((immediate) (base-char-reg))
29 (inst li y (char-code (tn-value x))))
31 (define-move-fun (load-system-area-pointer 1) (vop x y)
32 ((immediate) (sap-reg))
33 (inst lr y (sap-int (tn-value x))))
35 (define-move-fun (load-constant 5) (vop x y)
36 ((constant) (descriptor-reg))
37 (loadw y code-tn (tn-offset x) other-pointer-lowtag))
39 (define-move-fun (load-stack 5) (vop x y)
40 ((control-stack) (any-reg descriptor-reg))
43 (define-move-fun (load-number-stack 5) (vop x y)
44 ((base-char-stack) (base-char-reg)
46 (signed-stack) (signed-reg)
47 (unsigned-stack) (unsigned-reg))
48 (let ((nfp (current-nfp-tn vop)))
49 (loadw y nfp (tn-offset x))))
51 (define-move-fun (store-stack 5) (vop x y)
52 ((any-reg descriptor-reg) (control-stack))
55 (define-move-fun (store-number-stack 5) (vop x y)
56 ((base-char-reg) (base-char-stack)
58 (signed-reg) (signed-stack)
59 (unsigned-reg) (unsigned-stack))
60 (let ((nfp (current-nfp-tn vop)))
61 (storew x nfp (tn-offset y))))
68 :scs (any-reg descriptor-reg zero null)
69 :load-if (not (location= x y))))
70 (:results (y :scs (any-reg descriptor-reg)
71 :load-if (not (location= x y))))
77 (define-move-vop move :move
78 (any-reg descriptor-reg)
79 (any-reg descriptor-reg))
81 ;;; Make Move the check VOP for T so that type check generation doesn't think
82 ;;; it is a hairy type. This also allows checking of a few of the values in a
83 ;;; continuation to fall out.
85 (primitive-type-vop move (:check) t)
87 ;;; The Move-Argument VOP is used for moving descriptor values into another
88 ;;; frame for argument or known value passing.
90 (define-vop (move-arg)
92 :scs (any-reg descriptor-reg zero null))
94 :load-if (not (sc-is y any-reg descriptor-reg))))
98 ((any-reg descriptor-reg)
101 (storew x fp (tn-offset y))))))
103 (define-move-vop move-arg :move-arg
104 (any-reg descriptor-reg)
105 (any-reg descriptor-reg))
111 ;;; This VOP exists just to begin the lifetime of a TN that couldn't be written
112 ;;; legally due to a type error. An error is signalled before this VOP is
113 ;;; so we don't need to do anything (not that there would be anything sensible
116 (define-vop (illegal-move)
121 (:save-p :compute-only)
123 (error-call vop object-not-type-error x type)))
127 ;;;; Moves and coercions:
129 ;;; These MOVE-TO-WORD VOPs move a tagged integer to a raw full-word
130 ;;; representation. Similarly, the MOVE-FROM-WORD VOPs converts a raw integer
131 ;;; to a tagged bignum or fixnum.
133 ;;; Arg is a fixnum, so just shift it. We need a type restriction because some
134 ;;; possible arg SCs (control-stack) overlap with possible bignum arg SCs.
136 (define-vop (move-to-word/fixnum)
137 (:args (x :scs (any-reg descriptor-reg)))
138 (:results (y :scs (signed-reg unsigned-reg)))
139 (:arg-types tagged-num)
140 (:note "fixnum untagging")
144 (define-move-vop move-to-word/fixnum :move
145 (any-reg descriptor-reg) (signed-reg unsigned-reg))
147 ;;; Arg is a non-immediate constant, load it.
148 (define-vop (move-to-word-c)
149 (:args (x :scs (constant)))
150 (:results (y :scs (signed-reg unsigned-reg)))
151 (:note "constant load")
153 (inst lr y (tn-value x))))
155 (define-move-vop move-to-word-c :move
156 (constant) (signed-reg unsigned-reg))
159 ;;; Arg is a fixnum or bignum, figure out which and load if necessary.
160 (define-vop (move-to-word/integer)
161 (:args (x :scs (descriptor-reg)))
162 (:results (y :scs (signed-reg unsigned-reg)))
163 (:note "integer to untagged word coercion")
164 (:temporary (:scs (non-descriptor-reg)) temp)
166 (let ((done (gen-label)))
167 (inst andi. temp x 3)
175 (loadw y x bignum-digits-offset other-pointer-lowtag)
179 (define-move-vop move-to-word/integer :move
180 (descriptor-reg) (signed-reg unsigned-reg))
184 ;;; Result is a fixnum, so we can just shift. We need the result type
185 ;;; restriction because of the control-stack ambiguity noted above.
187 (define-vop (move-from-word/fixnum)
188 (:args (x :scs (signed-reg unsigned-reg)))
189 (:results (y :scs (any-reg descriptor-reg)))
190 (:result-types tagged-num)
191 (:note "fixnum tagging")
195 (define-move-vop move-from-word/fixnum :move
196 (signed-reg unsigned-reg) (any-reg descriptor-reg))
199 ;;; Result may be a bignum, so we have to check. Use a worst-case cost to make
200 ;;; sure people know they may be number consing.
202 (define-vop (move-from-signed)
203 (:args (arg :scs (signed-reg unsigned-reg) :target x))
204 (:results (y :scs (any-reg descriptor-reg)))
205 (:temporary (:scs (non-descriptor-reg) :from (:argument 0)) x temp)
206 (:temporary (:sc non-descriptor-reg :offset nl3-offset) pa-flag)
207 (:note "signed word to integer coercion")
210 (let ((done (gen-label)))
211 (inst mtxer zero-tn) ; clear sticky overflow bit in XER, CR0
212 (inst addo temp x x) ; set XER OV if top two bits differ
213 (inst addo. temp temp temp) ; set CR0 SO if any top three bits differ
214 (inst slwi y x 2) ; assume fixnum (tagged ok, maybe lost some high bits)
217 (with-fixed-allocation (y pa-flag temp bignum-widetag (1+ bignum-digits-offset))
218 (storew x y bignum-digits-offset other-pointer-lowtag))
221 (define-move-vop move-from-signed :move
222 (signed-reg) (descriptor-reg))
225 ;;; Check for fixnum, and possibly allocate one or two word bignum result. Use
226 ;;; a worst-case cost to make sure people know they may be number consing.
228 (define-vop (move-from-unsigned)
229 (:args (arg :scs (signed-reg unsigned-reg) :target x))
230 (:results (y :scs (any-reg descriptor-reg)))
231 (:temporary (:scs (non-descriptor-reg) :from (:argument 0)) x temp)
232 (:temporary (:sc non-descriptor-reg :offset nl3-offset) pa-flag)
233 (:note "unsigned word to integer coercion")
236 (let ((done (gen-label))
237 (one-word (gen-label))
238 (initial-alloc (pad-data-block (1+ bignum-digits-offset))))
239 (inst srawi. temp x 29)
243 (pseudo-atomic (pa-flag :extra initial-alloc)
245 (inst ori y alloc-tn other-pointer-lowtag)
246 (inst li temp (logior (ash 1 n-widetag-bits) bignum-widetag))
248 (inst addi alloc-tn alloc-tn
249 (- (pad-data-block (+ bignum-digits-offset 2))
250 (pad-data-block (+ bignum-digits-offset 1))))
251 (inst li temp (logior (ash 2 n-widetag-bits) bignum-widetag))
252 (emit-label one-word)
253 (storew temp y 0 other-pointer-lowtag)
254 (storew x y bignum-digits-offset other-pointer-lowtag))
257 (define-move-vop move-from-unsigned :move
258 (unsigned-reg) (descriptor-reg))
261 ;;; Move untagged numbers.
263 (define-vop (word-move)
265 :scs (signed-reg unsigned-reg)
266 :load-if (not (location= x y))))
267 (:results (y :scs (signed-reg unsigned-reg)
268 :load-if (not (location= x y))))
271 (:note "word integer move")
275 (define-move-vop word-move :move
276 (signed-reg unsigned-reg) (signed-reg unsigned-reg))
279 ;;; Move untagged number arguments/return-values.
281 (define-vop (move-word-arg)
283 :scs (signed-reg unsigned-reg))
285 :load-if (not (sc-is y sap-reg))))
287 (:note "word integer argument move")
290 ((signed-reg unsigned-reg)
292 ((signed-stack unsigned-stack)
293 (storew x fp (tn-offset y))))))
295 (define-move-vop move-word-arg :move-arg
296 (descriptor-reg any-reg signed-reg unsigned-reg) (signed-reg unsigned-reg))
299 ;;; Use standard MOVE-ARGUMENT + coercion to move an untagged number to a
300 ;;; descriptor passing location.
302 (define-move-vop move-arg :move-arg
303 (signed-reg unsigned-reg) (any-reg descriptor-reg))