| blob | 8d2418e1ad0ce650a17d0f900059edcc924dff69 |
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.
287 #'vop-info-more-arg-costs
288 nil)
291 #'vop-info-more-result-costs
292 t)
307 ;;; Prepare for the possibility of a TN being allocated on the number
308 ;;; stack by setting NUMBER-STACK-P in all functions that TN is
309 ;;; referenced in and in all the functions in their tail sets. REFS is
310 ;;; a TN-REFS list of references to the TN.
324 t)))
332 ;;; If TN is a variable, return the name. If TN is used by a VOP
333 ;;; emitted for a return, then return a string indicating this.
334 ;;; Otherwise, return NIL.
345 nil))))
347 ;;; If policy indicates, give an efficiency note for doing the
348 ;;; coercion VOP, where OP is the operand we are coercing for and
349 ;;; DEST-TN is the distinct destination in a move.
374 "doing ~A (cost ~W)~:[~2*~; ~:[to~;from~] ~S~], for:~%~6T~
375 the ~:R ~:[result~;argument~] of ~A"
376 note cost name arg-p name
377 pos arg-p op-note)))
384 ;;; Find a move VOP to move from the operand OP-TN to some other
385 ;;; representation corresponding to OTHER-SC and OTHER-PTYPE. SLOT is
386 ;;; the SC slot that we grab from (move or move-arg). WRITE-P
387 ;;; indicates that OP is a VOP result, so OP is the move result and
388 ;;; other is the arg, otherwise OP is the arg and other is the result.
389 ;;;
390 ;;; If an operand is of primitive type T, then we use the type of the
391 ;;; other operand instead, effectively intersecting the argument and
392 ;;; result type assertions. This way, a move VOP can restrict
393 ;;; whichever operand makes more sense, without worrying about which
394 ;;; operand has the type info.
409 nil)
420 ;;; Emit a coercion VOP for OP BEFORE the specifed VOP or die trying.
421 ;;; SCS is the operand's LOAD-SCS vector, which we use to determine
422 ;;; what SCs the VOP will accept. We pick any acceptable coerce VOP,
423 ;;; since it practice it seems uninteresting to have more than one
424 ;;; applicable.
425 ;;;
426 ;;; On the X86 port, stack SCs may be placed in the list of operand
427 ;;; preferred SCs, and to prevent these stack SCs being selected when
428 ;;; a register SC is available the non-stack SCs are searched first.
429 ;;;
430 ;;; What we do is look at each SC allowed by both the operand
431 ;;; restriction and the operand primitive-type, and see whether there
432 ;;; is a move VOP which moves between the operand's SC and load SC. If
433 ;;; we find such a VOP, then we make a TN having the load SC as the
434 ;;; representation.
435 ;;;
436 ;;; DEST-TN is the TN that we are moving to, for a move or move-arg.
437 ;;; This is only for efficiency notes.
438 ;;;
439 ;;; If the TN is an unused result TN, then we don't actually emit the
440 ;;; move; we just change to the right kind of TN.
467 before))))
468 t)))))
469 ;; Search the non-stack load SCs first.
476 ;; Search the stack SCs if the above failed.
484 ;;; Scan some operands and call EMIT-COERCE-VOP on any for which we
485 ;;; can't load the operand. The coerce VOP is inserted Before the
486 ;;; specified VOP. Dest-TN is the destination TN if we are doing a
487 ;;; move or move-arg, and is NIL otherwise. This is only used for
488 ;;; efficiency notes.
501 ;;; Emit coerce VOPs for the args and results, as needed.
510 ;;; Iterate over the more operands to a call VOP, emitting move-arg
511 ;;; VOPs and any necessary coercions. We determine which FP to use by
512 ;;; looking at the MOVE-ARGS annotation. If the vop is a :LOCAL-CALL,
513 ;;; we insert any needed coercions before the ALLOCATE-FRAME so that
514 ;;; lifetime analysis doesn't get confused (since otherwise, only
515 ;;; passing locations are written between A-F and call.)
525 nil))
556 node block
558 nfp-tn vop)
560 nfp-tn)))
562 pass-tn vop))
567 prev)
573 after)))))
576 ;;; Scan the IR2 looking for move operations that need to be replaced
577 ;;; with special-case VOPs and emitting coercion VOPs for operands of
578 ;;; normal VOPs. We delete moves to TNs that are never read at this
579 ;;; point, rather than possibly converting them to some expensive move
580 ;;; operation.
613 ;;; If TN is in a number stack SC, make all the right annotations.
614 ;;; Note that this should be called after TN has been referenced,
615 ;;; since it must iterate over the referencing environments.
628 ;;; This is the entry to representation selection. First we select the
629 ;;; representation for all normal TNs, setting the TN-SC. After
630 ;;; selecting the TN representations, we set the SC for all :ALIAS TNs
631 ;;; to be the representation chosen for the original TN. We then scan
632 ;;; all the IR2, emitting any necessary coerce and move-arg VOPs.
633 ;;; Finally, we scan all TNs looking for ones that might be placed on
634 ;;; the number stack, noting this so that the number-FP can be
635 ;;; allocated. This must be done last, since references in new
636 ;;; environments may be introduced by MOVE-ARG insertion.
641 ;; First pass; only allocate SCs where there is a distinct choice.