improve layout-invalid error message
[sbcl.git] / src / compiler / alpha / move.lisp
1 ;;;; the Alpha VM definition of operand loading/saving and the Move VOP
2
3 ;;;; This software is part of the SBCL system. See the README file for
4 ;;;; more information.
5 ;;;;
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.
11
12 (in-package "SB!VM")
13
14 (define-move-fun (load-immediate 1) (vop x y)
15   ((null zero immediate)
16    (any-reg descriptor-reg))
17   (let ((val (tn-value x)))
18     (etypecase val
19       (integer
20        (inst li (fixnumize val) y))
21       (null
22        (move null-tn y))
23       (symbol
24        (load-symbol y val))
25       (character
26        (inst li (logior (ash (char-code val) n-widetag-bits) character-widetag)
27              y)))))
28
29 (define-move-fun (load-number 1) (vop x y)
30   ((zero immediate)
31    (signed-reg unsigned-reg))
32   (inst li (tn-value x) y))
33
34 (define-move-fun (load-character 1) (vop x y)
35   ((immediate) (character-reg))
36   (inst li (char-code (tn-value x)) y))
37
38 (define-move-fun (load-system-area-pointer 1) (vop x y)
39   ((immediate) (sap-reg))
40   (inst li (sap-int (tn-value x)) y))
41
42 (define-move-fun (load-constant 5) (vop x y)
43   ((constant) (descriptor-reg any-reg))
44   (loadw y code-tn (tn-offset x) other-pointer-lowtag))
45
46 (define-move-fun (load-stack 5) (vop x y)
47   ((control-stack) (any-reg descriptor-reg))
48   (load-stack-tn y x))
49
50 (define-move-fun (load-number-stack 5) (vop x y)
51   ((character-stack) (character-reg))
52   (let ((nfp (current-nfp-tn vop)))
53     (loadw y nfp (tn-offset x))))
54
55 (define-move-fun (load-number-stack-64 5) (vop x y)
56   ((sap-stack) (sap-reg)
57    (signed-stack) (signed-reg)
58    (unsigned-stack) (unsigned-reg))
59   (let ((nfp (current-nfp-tn vop)))
60     (loadq y nfp (tn-offset x))))
61
62 (define-move-fun (store-stack 5) (vop x y)
63   ((any-reg descriptor-reg null zero) (control-stack))
64   (store-stack-tn y x))
65
66 (define-move-fun (store-number-stack 5) (vop x y)
67   ((character-reg) (character-stack))
68   (let ((nfp (current-nfp-tn vop)))
69     (storew x nfp (tn-offset y))))
70
71 (define-move-fun (store-number-stack-64 5) (vop x y)
72   ((sap-reg) (sap-stack)
73    (signed-reg) (signed-stack)
74    (unsigned-reg) (unsigned-stack))
75   (let ((nfp (current-nfp-tn vop)))
76     (storeq x nfp (tn-offset y))))
77 \f
78 ;;;; the MOVE VOP
79
80 (define-vop (move)
81   (:args (x :target y
82             :scs (any-reg descriptor-reg zero null)
83             :load-if (not (location= x y))))
84   (:results (y :scs (any-reg descriptor-reg control-stack)
85                :load-if (not (location= x y))))
86   (:effects)
87   (:affected)
88   (:generator 0
89     (unless (location= x y)
90       (sc-case y
91         ((any-reg descriptor-reg)
92          (inst move x y))
93         (control-stack
94          (store-stack-tn y x))))))
95
96 (define-move-vop move :move
97   (any-reg descriptor-reg zero null)
98   (any-reg descriptor-reg))
99
100 ;;; Make MOVE the check VOP for T so that type check generation
101 ;;; doesn't think it is a hairy type. This also allows checking of a
102 ;;; few of the values in a continuation to fall out.
103 (primitive-type-vop move (:check) t)
104
105 ;;; The MOVE-ARG VOP is used for moving descriptor values into
106 ;;; another frame for argument or known value passing.
107 (define-vop (move-arg)
108   (:args (x :target y
109             :scs (any-reg descriptor-reg null zero))
110          (fp :scs (any-reg)
111              :load-if (not (sc-is y any-reg descriptor-reg))))
112   (:results (y))
113   (:generator 0
114     (sc-case y
115       ((any-reg descriptor-reg)
116        (move x y))
117       (control-stack
118        (storew x fp (tn-offset y))))))
119 ;;;
120 (define-move-vop move-arg :move-arg
121   (any-reg descriptor-reg null zero)
122   (any-reg descriptor-reg))
123 \f
124 ;;;; ILLEGAL-MOVE
125
126 ;;; This VOP exists just to begin the lifetime of a TN that couldn't
127 ;;; be written legally due to a type error. An error is signalled
128 ;;; before this VOP is so we don't need to do anything (not that there
129 ;;; would be anything sensible to do anyway.)
130 (define-vop (illegal-move)
131   (:args (x) (type))
132   (:results (y))
133   (:ignore y)
134   (:vop-var vop)
135   (:save-p :compute-only)
136   (:generator 666
137     (error-call vop object-not-type-error x type)))
138 \f
139 ;;;; moves and coercions
140 ;;;;
141 ;;;; These MOVE-TO-WORD VOPs move a tagged integer to a raw full-word
142 ;;;; representation. Similarly, the MOVE-FROM-WORD VOPs converts a raw
143 ;;;; integer to a tagged bignum or fixnum.
144
145 ;;; ARG is a fixnum, so just shift it. We need a type restriction
146 ;;; because some possible arg SCs (control-stack) overlap with
147 ;;; possible bignum arg SCs.
148 (define-vop (move-to-word/fixnum)
149   (:args (x :scs (any-reg descriptor-reg)))
150   (:results (y :scs (signed-reg unsigned-reg)))
151   (:arg-types tagged-num)
152   (:note "fixnum untagging")
153   (:generator 1
154     (inst sra x n-fixnum-tag-bits y)))
155 (define-move-vop move-to-word/fixnum :move
156   (any-reg descriptor-reg) (signed-reg unsigned-reg))
157
158 ;;; ARG is a non-immediate constant, load it.
159 (define-vop (move-to-word-c)
160   (:args (x :scs (constant)))
161   (:results (y :scs (signed-reg unsigned-reg)))
162   (:note "constant load")
163   (:generator 1
164     (cond ((sb!c::tn-leaf x)
165            (inst li (tn-value x) y))
166           (t
167            (loadw y code-tn (tn-offset x) other-pointer-lowtag)
168            (inst sra y n-fixnum-tag-bits y)))))
169 (define-move-vop move-to-word-c :move
170   (constant) (signed-reg unsigned-reg))
171
172 ;;; ARG is a fixnum or bignum, figure out which and load if necessary.
173 (define-vop (move-to-word/integer)
174   (:args (x :scs (descriptor-reg)))
175   (:results (y :scs (signed-reg unsigned-reg)))
176   (:note "integer to untagged word coercion")
177   (:temporary (:sc non-descriptor-reg) header)
178   (:temporary (:scs (non-descriptor-reg)) temp)
179   (:generator 3
180     (inst and x fixnum-tag-mask temp)
181     (inst sra x n-fixnum-tag-bits y)
182     (inst beq temp done)
183
184     (loadw header x 0 other-pointer-lowtag)
185     (inst srl header (1+ n-widetag-bits) header)
186     (loadw y x bignum-digits-offset other-pointer-lowtag)
187     (inst beq header one)
188
189     (loadw header x (1+ bignum-digits-offset) other-pointer-lowtag)
190     (inst sll header 32 header)
191     (inst mskll y 4 y)
192     (inst bis header y y)
193     (inst br zero-tn done)
194     ONE
195     (when (sc-is y unsigned-reg)
196       (inst mskll y 4 y))
197     DONE))
198 (define-move-vop move-to-word/integer :move
199   (descriptor-reg) (signed-reg unsigned-reg))
200
201 ;;; RESULT is a fixnum, so we can just shift. We need the result type
202 ;;; restriction because of the control-stack ambiguity noted above.
203 (define-vop (move-from-word/fixnum)
204   (:args (x :scs (signed-reg unsigned-reg)))
205   (:results (y :scs (any-reg descriptor-reg)))
206   (:result-types tagged-num)
207   (:note "fixnum tagging")
208   (:generator 1
209     (inst sll x n-fixnum-tag-bits y)))
210 (define-move-vop move-from-word/fixnum :move
211   (signed-reg unsigned-reg) (any-reg descriptor-reg))
212
213 ;;; RESULT may be a bignum, so we have to check. Use a worst-case cost
214 ;;; to make sure people know they may be number consing.
215 (define-vop (move-from-signed)
216   (:args (arg :scs (signed-reg unsigned-reg) :target x))
217   (:results (y :scs (any-reg descriptor-reg)))
218   (:temporary (:scs (non-descriptor-reg) :from (:argument 0)) x temp)
219   (:temporary (:sc non-descriptor-reg) header)
220   (:note "signed word to integer coercion")
221   (:generator 18
222     (move arg x)
223     (inst sra x n-positive-fixnum-bits temp)
224     (inst sll x n-fixnum-tag-bits y)
225     (inst beq temp done)
226     (inst not temp temp)
227     (inst beq temp done)
228
229     (inst li 2 header)
230     (inst sra x 31 temp)
231     (inst cmoveq temp 1 header)
232     (inst not temp temp)
233     (inst cmoveq temp 1 header)
234     (inst sll header n-widetag-bits header)
235     (inst bis header bignum-widetag header)
236
237     (pseudo-atomic (:extra (pad-data-block (+ bignum-digits-offset 3)))
238       (inst bis alloc-tn other-pointer-lowtag y)
239       (storew header y 0 other-pointer-lowtag)
240       (storew x y bignum-digits-offset other-pointer-lowtag)
241       (inst srl x 32 temp)
242       (storew temp y (1+ bignum-digits-offset) other-pointer-lowtag))
243     DONE))
244 (define-move-vop move-from-signed :move
245   (signed-reg) (descriptor-reg))
246
247 ;;; Check for fixnum, and possibly allocate one or two word bignum
248 ;;; result. Use a worst-case cost to make sure people know they may be
249 ;;; number consing.
250 (define-vop (move-from-unsigned)
251   (:args (arg :scs (signed-reg unsigned-reg) :target x))
252   (:results (y :scs (any-reg descriptor-reg)))
253   (:temporary (:scs (non-descriptor-reg) :from (:argument 0)) x temp)
254   (:temporary (:sc non-descriptor-reg) temp1)
255   (:note "unsigned word to integer coercion")
256   (:generator 20
257     (move arg x)
258     (inst srl x n-positive-fixnum-bits temp)
259     (inst sll x n-fixnum-tag-bits y)
260     (inst beq temp done)
261
262     (inst li 3 temp)
263     (inst cmovge x 2 temp)
264     (inst srl x 31 temp1)
265     (inst cmoveq temp1 1 temp)
266     (inst sll temp n-widetag-bits temp)
267     (inst bis temp bignum-widetag temp)
268
269     (pseudo-atomic (:extra (pad-data-block (+ bignum-digits-offset 3)))
270       (inst bis alloc-tn other-pointer-lowtag y)
271       (storew temp y 0 other-pointer-lowtag)
272       (storew x y bignum-digits-offset other-pointer-lowtag)
273       (inst srl x 32 temp)
274       (storew temp y (1+ bignum-digits-offset) other-pointer-lowtag))
275     DONE))
276 (define-move-vop move-from-unsigned :move
277   (unsigned-reg) (descriptor-reg))
278
279 ;;; Move untagged numbers.
280 (define-vop (word-move)
281   (:args (x :target y
282             :scs (signed-reg unsigned-reg)
283             :load-if (not (location= x y))))
284   (:results (y :scs (signed-reg unsigned-reg)
285                :load-if (not (location= x y))))
286   (:effects)
287   (:affected)
288   (:note "word integer move")
289   (:generator 0
290     (move x y)))
291 (define-move-vop word-move :move
292   (signed-reg unsigned-reg) (signed-reg unsigned-reg))
293
294 ;;; Move untagged number arguments/return-values.
295 (define-vop (move-word-arg)
296   (:args (x :target y
297             :scs (signed-reg unsigned-reg))
298          (fp :scs (any-reg)
299              :load-if (not (sc-is y sap-reg))))
300   (:results (y))
301   (:note "word integer argument move")
302   (:generator 0
303     (sc-case y
304       ((signed-reg unsigned-reg)
305        (move x y))
306       ((signed-stack unsigned-stack)
307        (storeq x fp (tn-offset y))))))
308 (define-move-vop move-word-arg :move-arg
309   (descriptor-reg any-reg signed-reg unsigned-reg) (signed-reg unsigned-reg))
310
311
312 ;;; Use standard MOVE-ARG + coercion to move an untagged number
313 ;;; to a descriptor passing location.
314 (define-move-vop move-arg :move-arg
315   (signed-reg unsigned-reg) (any-reg descriptor-reg))