| blob | b43dd7767432dedbdd60648a4f7a65914feebae5 |
1 ;;;; This file contains the implementation-independent code for the
2 ;;;; representation selection phase in the compiler. Representation
3 ;;;; selection decides whether to use non-descriptor representations
4 ;;;; for objects and emits the appropriate representation-specific move
5 ;;;; and coerce vops.
7 ;;;; This software is part of the SBCL system. See the README file for
8 ;;;; more information.
9 ;;;;
10 ;;;; This software is derived from the CMU CL system, which was
11 ;;;; written at Carnegie Mellon University and released into the
12 ;;;; public domain. The software is in the public domain and is
13 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
14 ;;;; files for more information.
17 \f
18 ;;;; error routines
19 ;;;;
20 ;;;; Problems in the VM definition often show up here, so we try to be
21 ;;;; as implementor-friendly as possible.
23 ;;; Given a TN ref for a VOP argument or result, return these values:
24 ;;; 1. True if the operand is an argument, false otherwise.
25 ;;; 2. The ordinal position of the operand.
26 ;;; 3. True if the operand is a more operand, false otherwise.
27 ;;; 4. The costs for this operand.
28 ;;; 5. The load-scs vector for this operand (NIL if more-p.)
29 ;;; 6. True if the costs or SCs in the VOP-INFO are inconsistent with
30 ;;; the currently recorded ones.
44 (+ n
48 t
49 more-cost
50 nil
51 nil))
59 n)
60 arg-p)
65 nil
78 ;;; Convert a load-costs vector to the list of SCs allowed by the
79 ;;; operand restriction.
88 ;;; Try to give a helpful error message when REF has no cost specified
89 ;;; for some SC allowed by the TN's PRIMITIVE-TYPE.
106 ~S VOP, since the TN's primitive type ~S allows SCs:~% ~S~@
107 ~:[which cannot be coerced or loaded into the allowed SCs:~
108 ~% ~S~;~*~]~:[~;~@
109 Current cost info inconsistent with that in effect at compile ~
110 time. Recompile.~%Compilation order may be incorrect.~]"
111 tn pos arg-p
115 more-p
118 incon)))))
120 ;;; Try to give a helpful error message when we fail to do a coercion
121 ;;; for some reason.
157 ~% ~S~%Primitive type: ~S~@
158 SC restrictions:~% ~S~@
159 ~@[The primitive type disallows these loadable SCs:~% ~S~%~]~
160 ~@[No move VOPs are defined to coerce to these allowed SCs:~
161 ~% ~S~%~]~
162 ~@[These move VOPs couldn't be used due to operand type ~
163 restrictions:~% ~S~%~]~
164 ~:[~;~@
165 Current cost info inconsistent with that in effect at compile ~
166 time. Recompile.~%Compilation order may be incorrect.~]"
167 op-tn pos arg-p
174 incon)))))
179 ~S (SC ~S)"
182 \f
183 ;;;; VM consistency checking
184 ;;;;
185 ;;;; We do some checking of the consistency of the VM definition at
186 ;;;; load time.
188 ;;; FIXME: should probably be conditional on #!+SB-SHOW
197 SC ~S"
203 SC ~S"
207 SC ~S"
209 \f
210 ;;;; representation selection
212 ;;; VOPs that we ignore in initial cost computation. We ignore SET in
213 ;;; the hopes that nobody is setting specials inside of loops. We
214 ;;; ignore TYPE-CHECK-ERROR because we don't want the possibility of
215 ;;; error to bias the result. Notes are suppressed for T-C-E as well,
216 ;;; since we don't need to worry about the efficiency of that case.
220 ;;; We special-case the move VOP, since using this costs for the
221 ;;; normal MOVE would spuriously encourage descriptor representations.
222 ;;; We won't actually need to coerce to descriptor and back, since we
223 ;;; will replace the MOVE with a specialized move VOP. What we do is
224 ;;; look at the other operand. If its representation has already been
225 ;;; chosen (e.g. if it is wired), then we use the appropriate move
226 ;;; costs, otherwise we just ignore the references.
228 ops-slot costs-slot more-costs-slot
229 write-p)
271 ;;; Return the best representation for a normal TN. SCs is a list
272 ;;; of the SC numbers of the SCs to select from. Costs is a scratch
273 ;;; vector.
274 ;;;
275 ;;; What we do is sum the costs for each reference to TN in each of
276 ;;; the SCs, and then return the SC having the lowest cost. A second
277 ;;; value is returned which is true when the selection is unique which
278 ;;; is often not the case for the MOVE VOP.
286 #'vop-info-more-arg-costs
287 nil)
290 #'vop-info-more-result-costs
291 t)
306 ;;; Prepare for the possibility of a TN being allocated on the number
307 ;;; stack by setting NUMBER-STACK-P in all functions that TN is
308 ;;; referenced in and in all the functions in their tail sets. REFS is
309 ;;; a TN-REFS list of references to the TN.
323 t)))
331 ;;; If TN is a variable, return the name. If TN is used by a VOP
332 ;;; emitted for a return, then return a string indicating this.
333 ;;; Otherwise, return NIL.
344 nil))))
346 ;;; If policy indicates, give an efficiency note for doing the
347 ;;; coercion VOP, where OP is the operand we are coercing for and
348 ;;; DEST-TN is the distinct destination in a move.
373 "doing ~A (cost ~W)~:[~2*~; ~:[to~;from~] ~S~], for:~%~6T~
374 the ~:R ~:[result~;argument~] of ~A"
375 note cost name arg-p name
376 pos arg-p op-note)))
383 ;;; Find a move VOP to move from the operand OP-TN to some other
384 ;;; representation corresponding to OTHER-SC and OTHER-PTYPE. SLOT is
385 ;;; the SC slot that we grab from (move or move-arg). WRITE-P
386 ;;; indicates that OP is a VOP result, so OP is the move result and
387 ;;; other is the arg, otherwise OP is the arg and other is the result.
388 ;;;
389 ;;; If an operand is of primitive type T, then we use the type of the
390 ;;; other operand instead, effectively intersecting the argument and
391 ;;; result type assertions. This way, a move VOP can restrict
392 ;;; whichever operand makes more sense, without worrying about which
393 ;;; operand has the type info.
408 nil)
419 ;;; Emit a coercion VOP for OP BEFORE the specified VOP or die trying.
420 ;;; SCS is the operand's LOAD-SCS vector, which we use to determine
421 ;;; what SCs the VOP will accept. We pick any acceptable coerce VOP,
422 ;;; since it practice it seems uninteresting to have more than one
423 ;;; applicable.
424 ;;;
425 ;;; On the X86 port, stack SCs may be placed in the list of operand
426 ;;; preferred SCs, and to prevent these stack SCs being selected when
427 ;;; a register SC is available the non-stack SCs are searched first.
428 ;;;
429 ;;; What we do is look at each SC allowed by both the operand
430 ;;; restriction and the operand primitive-type, and see whether there
431 ;;; is a move VOP which moves between the operand's SC and load SC. If
432 ;;; we find such a VOP, then we make a TN having the load SC as the
433 ;;; representation.
434 ;;;
435 ;;; DEST-TN is the TN that we are moving to, for a move or move-arg.
436 ;;; This is only for efficiency notes.
437 ;;;
438 ;;; If the TN is an unused result TN, then we don't actually emit the
439 ;;; move; we just change to the right kind of TN.
466 before))))
467 t)))))
468 ;; Search the non-stack load SCs first.
475 ;; Search the stack SCs if the above failed.
483 ;;; Scan some operands and call EMIT-COERCE-VOP on any for which we
484 ;;; can't load the operand. The coerce VOP is inserted Before the
485 ;;; specified VOP. Dest-TN is the destination TN if we are doing a
486 ;;; move or move-arg, and is NIL otherwise. This is only used for
487 ;;; efficiency notes.
500 ;;; Emit coerce VOPs for the args and results, as needed.
509 ;;; Iterate over the more operands to a call VOP, emitting move-arg
510 ;;; VOPs and any necessary coercions. We determine which FP to use by
511 ;;; looking at the MOVE-ARGS annotation. If the vop is a :LOCAL-CALL,
512 ;;; we insert any needed coercions before the ALLOCATE-FRAME so that
513 ;;; lifetime analysis doesn't get confused (since otherwise, only
514 ;;; passing locations are written between A-F and call.)
524 nil))
555 node block
557 nfp-tn vop)
559 nfp-tn)))
561 pass-tn vop))
566 prev)
572 after)))))
575 ;;; Scan the IR2 looking for move operations that need to be replaced
576 ;;; with special-case VOPs and emitting coercion VOPs for operands of
577 ;;; normal VOPs. We delete moves to TNs that are never read at this
578 ;;; point, rather than possibly converting them to some expensive move
579 ;;; operation.
612 ;;; If TN is in a number stack SC, make all the right annotations.
613 ;;; Note that this should be called after TN has been referenced,
614 ;;; since it must iterate over the referencing environments.
627 ;;; This is the entry to representation selection. First we select the
628 ;;; representation for all normal TNs, setting the TN-SC. After
629 ;;; selecting the TN representations, we set the SC for all :ALIAS TNs
630 ;;; to be the representation chosen for the original TN. We then scan
631 ;;; all the IR2, emitting any necessary coerce and move-arg VOPs.
632 ;;; Finally, we scan all TNs looking for ones that might be placed on
633 ;;; the number stack, noting this so that the number-FP can be
634 ;;; allocated. This must be done last, since references in new
635 ;;; environments may be introduced by MOVE-ARG insertion.
640 ;; First pass; only allocate SCs where there is a distinct choice.