1.0.31.13: working XREF for inlined lambda with hairy lambda-lists
[sbcl.git] / src / compiler / pack.lisp
1 ;;;; This file contains the implementation-independent code for Pack
2 ;;;; phase in the compiler. Pack is responsible for assigning TNs to
3 ;;;; storage allocations or "register allocation".
4
5 ;;;; This software is part of the SBCL system. See the README file for
6 ;;;; more information.
7 ;;;;
8 ;;;; This software is derived from the CMU CL system, which was
9 ;;;; written at Carnegie Mellon University and released into the
10 ;;;; public domain. The software is in the public domain and is
11 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
12 ;;;; files for more information.
13
14 (in-package "SB!C")
15
16 ;;; for debugging: some parameters controlling which optimizations we
17 ;;; attempt
18 (defvar *pack-assign-costs* t)
19 (defvar *pack-optimize-saves* t)
20 ;;; FIXME: Perhaps SB-FLUID should be renamed to SB-TWEAK and these
21 ;;; should be made conditional on SB-TWEAK.
22
23 (declaim (ftype (function (component) index) ir2-block-count))
24 \f
25 ;;;; conflict determination
26
27 ;;; Return true if the element at the specified offset in SB has a
28 ;;; conflict with TN:
29 ;;; -- If a component-live TN (:COMPONENT kind), then iterate over
30 ;;;    all the blocks. If the element at OFFSET is used anywhere in
31 ;;;    any of the component's blocks (always-live /= 0), then there
32 ;;;    is a conflict.
33 ;;; -- If TN is global (Confs true), then iterate over the blocks TN
34 ;;;    is live in (using TN-GLOBAL-CONFLICTS). If the TN is live
35 ;;;    everywhere in the block (:LIVE), then there is a conflict
36 ;;;    if the element at offset is used anywhere in the block
37 ;;;    (Always-Live /= 0). Otherwise, we use the local TN number for
38 ;;;    TN in block to find whether TN has a conflict at Offset in
39 ;;;    that block.
40 ;;; -- If TN is local, then we just check for a conflict in the block
41 ;;;    it is local to.
42 (defun offset-conflicts-in-sb (tn sb offset)
43   (declare (type tn tn) (type finite-sb sb) (type index offset))
44   (let ((confs (tn-global-conflicts tn))
45         (kind (tn-kind tn)))
46     (cond
47      ((eq kind :component)
48       (let ((loc-live (svref (finite-sb-always-live sb) offset)))
49         (dotimes (i (ir2-block-count *component-being-compiled*) nil)
50           (when (/= (sbit loc-live i) 0)
51             (return t)))))
52      (confs
53       (let ((loc-confs (svref (finite-sb-conflicts sb) offset))
54             (loc-live (svref (finite-sb-always-live sb) offset)))
55         (do ((conf confs (global-conflicts-next-tnwise conf)))
56             ((null conf)
57              nil)
58           (let* ((block (global-conflicts-block conf))
59                  (num (ir2-block-number block)))
60             (if (eq (global-conflicts-kind conf) :live)
61                 (when (/= (sbit loc-live num) 0)
62                   (return t))
63                 (when (/= (sbit (svref loc-confs num)
64                                 (global-conflicts-number conf))
65                           0)
66                   (return t)))))))
67      (t
68       (/= (sbit (svref (svref (finite-sb-conflicts sb) offset)
69                        (ir2-block-number (tn-local tn)))
70                 (tn-local-number tn))
71           0)))))
72
73 ;;; Return true if TN has a conflict in SC at the specified offset.
74 (defun conflicts-in-sc (tn sc offset)
75   (declare (type tn tn) (type sc sc) (type index offset))
76   (let ((sb (sc-sb sc)))
77     (dotimes (i (sc-element-size sc) nil)
78       (when (offset-conflicts-in-sb tn sb (+ offset i))
79         (return t)))))
80
81 ;;; Add TN's conflicts into the conflicts for the location at OFFSET
82 ;;; in SC. We iterate over each location in TN, adding to the
83 ;;; conflicts for that location:
84 ;;; -- If TN is a :COMPONENT TN, then iterate over all the blocks,
85 ;;;    setting all of the local conflict bits and the always-live bit.
86 ;;;    This records a conflict with any TN that has a LTN number in
87 ;;;    the block, as well as with :ALWAYS-LIVE and :ENVIRONMENT TNs.
88 ;;; -- If TN is global, then iterate over the blocks TN is live in. In
89 ;;;    addition to setting the always-live bit to represent the conflict
90 ;;;    with TNs live throughout the block, we also set bits in the
91 ;;;    local conflicts. If TN is :ALWAYS-LIVE in the block, we set all
92 ;;;    the bits, otherwise we OR in the local conflict bits.
93 ;;; -- If the TN is local, then we just do the block it is local to,
94 ;;;    setting always-live and OR'ing in the local conflicts.
95 (defun add-location-conflicts (tn sc offset optimize)
96   (declare (type tn tn) (type sc sc) (type index offset))
97   (let ((confs (tn-global-conflicts tn))
98         (sb (sc-sb sc))
99         (kind (tn-kind tn)))
100     (dotimes (i (sc-element-size sc))
101       (declare (type index i))
102       (let* ((this-offset (+ offset i))
103              (loc-confs (svref (finite-sb-conflicts sb) this-offset))
104              (loc-live (svref (finite-sb-always-live sb) this-offset)))
105         (cond
106          ((eq kind :component)
107           (dotimes (num (ir2-block-count *component-being-compiled*))
108             (declare (type index num))
109             (setf (sbit loc-live num) 1)
110             (set-bit-vector (svref loc-confs num))))
111          (confs
112           (do ((conf confs (global-conflicts-next-tnwise conf)))
113               ((null conf))
114             (let* ((block (global-conflicts-block conf))
115                    (num (ir2-block-number block))
116                    (local-confs (svref loc-confs num)))
117               (declare (type local-tn-bit-vector local-confs))
118               (setf (sbit loc-live num) 1)
119               (if (eq (global-conflicts-kind conf) :live)
120                   (set-bit-vector local-confs)
121                   (bit-ior local-confs (global-conflicts-conflicts conf) t)))))
122          (t
123           (let ((num (ir2-block-number (tn-local tn))))
124             (setf (sbit loc-live num) 1)
125             (bit-ior (the local-tn-bit-vector (svref loc-confs num))
126                      (tn-local-conflicts tn) t))))
127         ;; Calculating ALWAYS-LIVE-COUNT is moderately expensive, and
128         ;; currently the information isn't used unless (> SPEED
129         ;; COMPILE-SPEED).
130         (when optimize
131           (setf (svref (finite-sb-always-live-count sb) this-offset)
132                 (find-location-usage sb this-offset))))))
133   (values))
134
135 ;; A rought measure of how much a given OFFSET in SB is currently
136 ;; used. Current implementation counts the amount of blocks where the
137 ;; offset has been marked as ALWAYS-LIVE.
138 (defun find-location-usage (sb offset)
139   (declare (optimize speed))
140   (declare (type sb sb) (type index offset))
141   (let* ((always-live (svref (finite-sb-always-live sb) offset)))
142     (declare (simple-bit-vector always-live))
143     (count 1 always-live)))
144
145 ;;; Return the total number of IR2-BLOCKs in COMPONENT.
146 (defun ir2-block-count (component)
147   (declare (type component component))
148   (do ((2block (block-info (block-next (component-head component)))
149                (ir2-block-next 2block)))
150       ((null 2block)
151        (error "What?  No ir2 blocks have a non-nil number?"))
152     (when (ir2-block-number 2block)
153       (return (1+ (ir2-block-number 2block))))))
154
155 ;;; Ensure that the conflicts vectors for each :FINITE SB are large
156 ;;; enough for the number of blocks allocated. Also clear any old
157 ;;; conflicts and reset the current size to the initial size.
158 (defun init-sb-vectors (component)
159   (let ((nblocks (ir2-block-count component)))
160     (dolist (sb *backend-sb-list*)
161       (unless (eq (sb-kind sb) :non-packed)
162         (let* ((conflicts (finite-sb-conflicts sb))
163                (always-live (finite-sb-always-live sb))
164                (always-live-count (finite-sb-always-live-count sb))
165                (max-locs (length conflicts))
166                (last-count (finite-sb-last-block-count sb)))
167           (unless (zerop max-locs)
168             (let ((current-size (length (the simple-vector
169                                              (svref conflicts 0)))))
170               (cond
171                ((> nblocks current-size)
172                 (let ((new-size (max nblocks (* current-size 2))))
173                   (declare (type index new-size))
174                   (dotimes (i max-locs)
175                     (declare (type index i))
176                     (let ((new-vec (make-array new-size)))
177                       (let ((old (svref conflicts i)))
178                         (declare (simple-vector old))
179                         (dotimes (j current-size)
180                           (declare (type index j))
181                           (setf (svref new-vec j)
182                                 (clear-bit-vector (svref old j)))))
183
184                       (do ((j current-size (1+ j)))
185                           ((= j new-size))
186                         (declare (type index j))
187                         (setf (svref new-vec j)
188                               (make-array local-tn-limit :element-type 'bit
189                                           :initial-element 0)))
190                       (setf (svref conflicts i) new-vec))
191                     (setf (svref always-live i)
192                           (make-array new-size :element-type 'bit
193                                       :initial-element 0))
194                     (setf (svref always-live-count i) 0))))
195                (t
196                 (dotimes (i (finite-sb-current-size sb))
197                   (declare (type index i))
198                   (let ((conf (svref conflicts i)))
199                     (declare (simple-vector conf))
200                     (dotimes (j last-count)
201                       (declare (type index j))
202                       (clear-bit-vector (svref conf j))))
203                   (clear-bit-vector (svref always-live i))
204                   (setf (svref always-live-count i) 0))))))
205
206           (setf (finite-sb-last-block-count sb) nblocks)
207           (setf (finite-sb-current-size sb) (sb-size sb))
208           (setf (finite-sb-last-offset sb) 0))))))
209
210 ;;; Expand the :UNBOUNDED SB backing SC by either the initial size or
211 ;;; the SC element size, whichever is larger. If NEEDED-SIZE is
212 ;;; larger, then use that size.
213 (defun grow-sc (sc &optional (needed-size 0))
214   (declare (type sc sc) (type index needed-size))
215   (let* ((sb (sc-sb sc))
216          (size (finite-sb-current-size sb))
217          (align-mask (1- (sc-alignment sc)))
218          (inc (max (sb-size sb)
219                    (+ (sc-element-size sc)
220                       (- (logandc2 (+ size align-mask) align-mask)
221                          size))
222                    (- needed-size size)))
223          (new-size (+ size inc))
224          (conflicts (finite-sb-conflicts sb))
225          (block-size (if (zerop (length conflicts))
226                          (ir2-block-count *component-being-compiled*)
227                          (length (the simple-vector (svref conflicts 0))))))
228     (declare (type index inc new-size))
229     (aver (eq (sb-kind sb) :unbounded))
230
231     (when (> new-size (length conflicts))
232       (let ((new-conf (make-array new-size)))
233         (replace new-conf conflicts)
234         (do ((i size (1+ i)))
235             ((= i new-size))
236           (declare (type index i))
237           (let ((loc-confs (make-array block-size)))
238             (dotimes (j block-size)
239               (setf (svref loc-confs j)
240                     (make-array local-tn-limit
241                                 :initial-element 0
242                                 :element-type 'bit)))
243             (setf (svref new-conf i) loc-confs)))
244         (setf (finite-sb-conflicts sb) new-conf))
245
246       (let ((new-live (make-array new-size)))
247         (replace new-live (finite-sb-always-live sb))
248         (do ((i size (1+ i)))
249             ((= i new-size))
250           (setf (svref new-live i)
251                 (make-array block-size
252                             :initial-element 0
253                             :element-type 'bit)))
254         (setf (finite-sb-always-live sb) new-live))
255
256       (let ((new-live-count (make-array new-size)))
257         (declare (optimize speed)) ;; FILL deftransform
258         (replace new-live-count (finite-sb-always-live-count sb))
259         (fill new-live-count 0 :start size)
260         (setf (finite-sb-always-live-count sb) new-live-count))
261
262       (let ((new-tns (make-array new-size :initial-element nil)))
263         (replace new-tns (finite-sb-live-tns sb))
264         (fill (finite-sb-live-tns sb) nil)
265         (setf (finite-sb-live-tns sb) new-tns)))
266
267     (setf (finite-sb-current-size sb) new-size))
268   (values))
269
270 \f
271 ;;;; internal errors
272
273 ;;; Give someone a hard time because there isn't any load function
274 ;;; defined to move from SRC to DEST.
275 (defun no-load-fun-error (src dest)
276   (let* ((src-sc (tn-sc src))
277          (src-name (sc-name src-sc))
278          (dest-sc (tn-sc dest))
279          (dest-name (sc-name dest-sc)))
280     (cond ((eq (sb-kind (sc-sb src-sc)) :non-packed)
281            (unless (member src-sc (sc-constant-scs dest-sc))
282              (error "loading from an invalid constant SC?~@
283                      VM definition inconsistent, try recompiling."))
284            (error "no load function defined to load SC ~S ~
285                    from its constant SC ~S"
286                   dest-name src-name))
287           ((member src-sc (sc-alternate-scs dest-sc))
288            (error "no load function defined to load SC ~S from its ~
289                    alternate SC ~S"
290                   dest-name src-name))
291           ((member dest-sc (sc-alternate-scs src-sc))
292            (error "no load function defined to save SC ~S in its ~
293                    alternate SC ~S"
294                   src-name dest-name))
295           (t
296            ;; FIXME: "VM definition is inconsistent" shouldn't be a
297            ;; possibility in SBCL.
298            (error "loading to/from SCs that aren't alternates?~@
299                    VM definition is inconsistent, try recompiling.")))))
300
301 ;;; Called when we failed to pack TN. If RESTRICTED is true, then we
302 ;;; are restricted to pack TN in its SC.
303 (defun failed-to-pack-error (tn restricted)
304   (declare (type tn tn))
305   (let* ((sc (tn-sc tn))
306          (scs (cons sc (sc-alternate-scs sc))))
307     (cond
308      (restricted
309       (error "failed to pack restricted TN ~S in its SC ~S"
310              tn (sc-name sc)))
311      (t
312       (aver (not (find :unbounded scs
313                        :key (lambda (x) (sb-kind (sc-sb x))))))
314       (let ((ptype (tn-primitive-type tn)))
315         (cond
316          (ptype
317           (aver (member (sc-number sc) (primitive-type-scs ptype)))
318           (error "SC ~S doesn't have any :UNBOUNDED alternate SCs, but is~@
319                   a SC for primitive-type ~S."
320                  (sc-name sc) (primitive-type-name ptype)))
321          (t
322           (error "SC ~S doesn't have any :UNBOUNDED alternate SCs."
323                  (sc-name sc)))))))))
324
325 ;;; Return a list of format arguments describing how TN is used in
326 ;;; OP's VOP.
327 (defun describe-tn-use (loc tn op)
328   (let* ((vop (tn-ref-vop op))
329          (args (vop-args vop))
330          (results (vop-results vop))
331          (name (with-output-to-string (stream)
332                  (print-tn-guts tn stream)))
333          (2comp (component-info *component-being-compiled*))
334          temp)
335     (cond
336      ((setq temp (position-in #'tn-ref-across tn args :key #'tn-ref-tn))
337       `("~2D: ~A (~:R argument)" ,loc ,name ,(1+ temp)))
338      ((setq temp (position-in #'tn-ref-across tn results :key #'tn-ref-tn))
339       `("~2D: ~A (~:R result)" ,loc ,name ,(1+ temp)))
340      ((setq temp (position-in #'tn-ref-across tn args :key #'tn-ref-load-tn))
341       `("~2D: ~A (~:R argument load TN)" ,loc ,name ,(1+ temp)))
342      ((setq temp (position-in #'tn-ref-across tn results :key
343                               #'tn-ref-load-tn))
344       `("~2D: ~A (~:R result load TN)" ,loc ,name ,(1+ temp)))
345      ((setq temp (position-in #'tn-ref-across tn (vop-temps vop)
346                               :key #'tn-ref-tn))
347       `("~2D: ~A (temporary ~A)" ,loc ,name
348         ,(operand-parse-name (elt (vop-parse-temps
349                                    (vop-parse-or-lose
350                                     (vop-info-name  (vop-info vop))))
351                                   temp))))
352      ((eq (tn-kind tn) :component)
353       `("~2D: ~A (component live)" ,loc ,name))
354      ((position-in #'tn-next tn (ir2-component-wired-tns 2comp))
355       `("~2D: ~A (wired)" ,loc ,name))
356      ((position-in #'tn-next tn (ir2-component-restricted-tns 2comp))
357       `("~2D: ~A (restricted)" ,loc ,name))
358      (t
359       `("~2D: not referenced?" ,loc)))))
360
361 ;;; If load TN packing fails, try to give a helpful error message. We
362 ;;; find a TN in each location that conflicts, and print it.
363 (defun failed-to-pack-load-tn-error (scs op)
364   (declare (list scs) (type tn-ref op))
365   (collect ((used)
366             (unused))
367     (dolist (sc scs)
368       (let* ((sb (sc-sb sc))
369              (confs (finite-sb-live-tns sb)))
370         (aver (eq (sb-kind sb) :finite))
371         (dolist (el (sc-locations sc))
372           (declare (type index el))
373           (let ((conf (load-tn-conflicts-in-sc op sc el t)))
374             (if conf
375                 (used (describe-tn-use el conf op))
376                 (do ((i el (1+ i))
377                      (end (+ el (sc-element-size sc))))
378                     ((= i end)
379                      (unused el))
380                   (declare (type index i end))
381                   (let ((victim (svref confs i)))
382                     (when victim
383                       (used (describe-tn-use el victim op))
384                       (return t)))))))))
385
386     (multiple-value-bind (arg-p n more-p costs load-scs incon)
387         (get-operand-info op)
388       (declare (ignore costs load-scs))
389         (aver (not more-p))
390         (error "unable to pack a Load-TN in SC ~{~A~#[~^~;, or ~:;,~]~} ~
391                 for the ~:R ~:[result~;argument~] to~@
392                 the ~S VOP,~@
393                 ~:[since all SC elements are in use:~:{~%~@?~}~%~;~
394                 ~:*but these SC elements are not in use:~%  ~S~%Bug?~*~]~
395                 ~:[~;~@
396                 Current cost info inconsistent with that in effect at compile ~
397                 time. Recompile.~%Compilation order may be incorrect.~]"
398                (mapcar #'sc-name scs)
399                n arg-p
400                (vop-info-name (vop-info (tn-ref-vop op)))
401                (unused) (used)
402                incon))))
403
404 ;;; This is called when none of the SCs that we can load OP into are
405 ;;; allowed by OP's primitive-type.
406 (defun no-load-scs-allowed-by-primitive-type-error (ref)
407   (declare (type tn-ref ref))
408   (let* ((tn (tn-ref-tn ref))
409          (ptype (tn-primitive-type tn)))
410     (multiple-value-bind (arg-p pos more-p costs load-scs incon)
411         (get-operand-info ref)
412       (declare (ignore costs))
413       (aver (not more-p))
414       (error "~S is not valid as the ~:R ~:[result~;argument~] to VOP:~
415               ~%  ~S,~@
416               since the TN's primitive type ~S doesn't allow any of the SCs~@
417               allowed by the operand restriction:~%  ~S~
418               ~:[~;~@
419               Current cost info inconsistent with that in effect at compile ~
420               time. Recompile.~%Compilation order may be incorrect.~]"
421              tn pos arg-p
422              (template-name (vop-info (tn-ref-vop ref)))
423              (primitive-type-name ptype)
424              (mapcar #'sc-name (listify-restrictions load-scs))
425              incon))))
426 \f
427 ;;;; register saving
428
429 ;;; Do stuff to note that TN is spilled at VOP for the debugger's benefit.
430 (defun note-spilled-tn (tn vop)
431   (when (and (tn-leaf tn) (vop-save-set vop))
432     (let ((2comp (component-info *component-being-compiled*)))
433       (setf (gethash tn (ir2-component-spilled-tns 2comp)) t)
434       (pushnew tn (gethash vop (ir2-component-spilled-vops 2comp)))))
435   (values))
436
437 ;;; Make a save TN for TN, pack it, and return it. We copy various
438 ;;; conflict information from the TN so that pack does the right
439 ;;; thing.
440 (defun pack-save-tn (tn)
441   (declare (type tn tn))
442   (let ((res (make-tn 0 :save nil nil)))
443     (dolist (alt (sc-alternate-scs (tn-sc tn))
444                  (error "no unbounded alternate for SC ~S"
445                         (sc-name (tn-sc tn))))
446       (when (eq (sb-kind (sc-sb alt)) :unbounded)
447         (setf (tn-save-tn tn) res)
448         (setf (tn-save-tn res) tn)
449         (setf (tn-sc res) alt)
450         (pack-tn res t nil)
451         (return res)))))
452
453 ;;; Find the load function for moving from SRC to DEST and emit a
454 ;;; MOVE-OPERAND VOP with that function as its info arg.
455 (defun emit-operand-load (node block src dest before)
456   (declare (type node node) (type ir2-block block)
457            (type tn src dest) (type (or vop null) before))
458   (emit-load-template node block
459                       (template-or-lose 'move-operand)
460                       src dest
461                       (list (or (svref (sc-move-funs (tn-sc dest))
462                                        (sc-number (tn-sc src)))
463                                 (no-load-fun-error src dest)))
464                       before)
465   (values))
466
467 ;;; Find the preceding use of the VOP NAME in the emit order, starting
468 ;;; with VOP. We must find the VOP in the same IR1 block.
469 (defun reverse-find-vop (name vop)
470   (do* ((block (vop-block vop) (ir2-block-prev block))
471         (last vop (ir2-block-last-vop block)))
472        (nil)
473     (aver (eq (ir2-block-block block) (ir2-block-block (vop-block vop))))
474     (do ((current last (vop-prev current)))
475         ((null current))
476       (when (eq (vop-info-name (vop-info current)) name)
477         (return-from reverse-find-vop current)))))
478
479 ;;; For TNs that have other than one writer, we save the TN before
480 ;;; each call. If a local call (MOVE-ARGS is :LOCAL-CALL), then we
481 ;;; scan back for the ALLOCATE-FRAME VOP, and emit the save there.
482 ;;; This is necessary because in a self-recursive local call, the
483 ;;; registers holding the current arguments may get trashed by setting
484 ;;; up the call arguments. The ALLOCATE-FRAME VOP marks a place at
485 ;;; which the values are known to be good.
486 (defun save-complex-writer-tn (tn vop)
487   (let ((save (or (tn-save-tn tn)
488                   (pack-save-tn tn)))
489         (node (vop-node vop))
490         (block (vop-block vop))
491         (next (vop-next vop)))
492     (when (eq (tn-kind save) :specified-save)
493       (setf (tn-kind save) :save))
494     (aver (eq (tn-kind save) :save))
495     (emit-operand-load node block tn save
496                        (if (eq (vop-info-move-args (vop-info vop))
497                                :local-call)
498                            (reverse-find-vop 'allocate-frame vop)
499                            vop))
500     (emit-operand-load node block save tn next)))
501
502 ;;; Return a VOP after which is an OK place to save the value of TN.
503 ;;; For correctness, it is only required that this location be after
504 ;;; any possible write and before any possible restore location.
505 ;;;
506 ;;; In practice, we return the unique writer VOP, but give up if the
507 ;;; TN is ever read by a VOP with MOVE-ARGS :LOCAL-CALL. This prevents
508 ;;; us from being confused by non-tail local calls.
509 ;;;
510 ;;; When looking for writes, we have to ignore uses of MOVE-OPERAND,
511 ;;; since they will correspond to restores that we have already done.
512 (defun find-single-writer (tn)
513   (declare (type tn tn))
514   (do ((write (tn-writes tn) (tn-ref-next write))
515        (res nil))
516       ((null write)
517        (when (and res
518                   (do ((read (tn-reads tn) (tn-ref-next read)))
519                       ((not read) t)
520                     (when (eq (vop-info-move-args
521                                (vop-info
522                                 (tn-ref-vop read)))
523                               :local-call)
524                       (return nil))))
525          (tn-ref-vop res)))
526
527     (unless (eq (vop-info-name (vop-info (tn-ref-vop write)))
528                 'move-operand)
529       (when res (return nil))
530       (setq res write))))
531
532 ;;; Try to save TN at a single location. If we succeed, return T,
533 ;;; otherwise NIL.
534 (defun save-single-writer-tn (tn)
535   (declare (type tn tn))
536   (let* ((old-save (tn-save-tn tn))
537          (save (or old-save (pack-save-tn tn)))
538          (writer (find-single-writer tn)))
539     (when (and writer
540                (or (not old-save)
541                    (eq (tn-kind old-save) :specified-save)))
542       (emit-operand-load (vop-node writer) (vop-block writer)
543                          tn save (vop-next writer))
544       (setf (tn-kind save) :save-once)
545       t)))
546
547 ;;; Restore a TN with a :SAVE-ONCE save TN.
548 (defun restore-single-writer-tn (tn vop)
549   (declare (type tn) (type vop vop))
550   (let ((save (tn-save-tn tn)))
551     (aver (eq (tn-kind save) :save-once))
552     (emit-operand-load (vop-node vop) (vop-block vop) save tn (vop-next vop)))
553   (values))
554
555 ;;; Save a single TN that needs to be saved, choosing save-once if
556 ;;; appropriate. This is also called by SPILL-AND-PACK-LOAD-TN.
557 (defun basic-save-tn (tn vop)
558   (declare (type tn tn) (type vop vop))
559   (let ((save (tn-save-tn tn)))
560     (cond ((and save (eq (tn-kind save) :save-once))
561            (restore-single-writer-tn tn vop))
562           ((save-single-writer-tn tn)
563            (restore-single-writer-tn tn vop))
564           (t
565            (save-complex-writer-tn tn vop))))
566   (values))
567
568 ;;; Scan over the VOPs in BLOCK, emiting saving code for TNs noted in
569 ;;; the codegen info that are packed into saved SCs.
570 (defun emit-saves (block)
571   (declare (type ir2-block block))
572   (do ((vop (ir2-block-start-vop block) (vop-next vop)))
573       ((null vop))
574     (when (eq (vop-info-save-p (vop-info vop)) t)
575       (do-live-tns (tn (vop-save-set vop) block)
576         (when (and (sc-save-p (tn-sc tn))
577                    (not (eq (tn-kind tn) :component)))
578           (basic-save-tn tn vop)))))
579
580   (values))
581 \f
582 ;;;; optimized saving
583
584 ;;; Save TN if it isn't a single-writer TN that has already been
585 ;;; saved. If multi-write, we insert the save BEFORE the specified
586 ;;; VOP. CONTEXT is a VOP used to tell which node/block to use for the
587 ;;; new VOP.
588 (defun save-if-necessary (tn before context)
589   (declare (type tn tn) (type (or vop null) before) (type vop context))
590   (let ((save (tn-save-tn tn)))
591     (when (eq (tn-kind save) :specified-save)
592       (setf (tn-kind save) :save))
593     (aver (member (tn-kind save) '(:save :save-once)))
594     (unless (eq (tn-kind save) :save-once)
595       (or (save-single-writer-tn tn)
596           (emit-operand-load (vop-node context) (vop-block context)
597                              tn save before))))
598   (values))
599
600 ;;; Load the TN from its save location, allocating one if necessary.
601 ;;; The load is inserted BEFORE the specifier VOP. CONTEXT is a VOP
602 ;;; used to tell which node/block to use for the new VOP.
603 (defun restore-tn (tn before context)
604   (declare (type tn tn) (type (or vop null) before) (type vop context))
605   (let ((save (or (tn-save-tn tn) (pack-save-tn tn))))
606     (emit-operand-load (vop-node context) (vop-block context)
607                        save tn before))
608   (values))
609
610 ;;; Start scanning backward at the end of BLOCK, looking which TNs are
611 ;;; live and looking for places where we have to save. We manipulate
612 ;;; two sets: SAVES and RESTORES.
613 ;;;
614 ;;; SAVES is a set of all the TNs that have to be saved because they
615 ;;; are restored after some call. We normally delay saving until the
616 ;;; beginning of the block, but we must save immediately if we see a
617 ;;; write of the saved TN. We also immediately save all TNs and exit
618 ;;; when we see a NOTE-ENVIRONMENT-START VOP, since saves can't be
619 ;;; done before the environment is properly initialized.
620 ;;;
621 ;;; RESTORES is a set of all the TNs read (and not written) between
622 ;;; here and the next call, i.e. the set of TNs that must be restored
623 ;;; when we reach the next (earlier) call VOP. Unlike SAVES, this set
624 ;;; is cleared when we do the restoring after a call. Any TNs that
625 ;;; were in RESTORES are moved into SAVES to ensure that they are
626 ;;; saved at some point.
627 ;;;
628 ;;; SAVES and RESTORES are represented using both a list and a
629 ;;; bit-vector so that we can quickly iterate and test for membership.
630 ;;; The incoming SAVES and RESTORES args are used for computing these
631 ;;; sets (the initial contents are ignored.)
632 ;;;
633 ;;; When we hit a VOP with :COMPUTE-ONLY SAVE-P (an internal error
634 ;;; location), we pretend that all live TNs were read, unless (= speed
635 ;;; 3), in which case we mark all the TNs that are live but not
636 ;;; restored as spilled.
637 (defun optimized-emit-saves-block (block saves restores)
638   (declare (type ir2-block block) (type simple-bit-vector saves restores))
639   (let ((1block (ir2-block-block block))
640         (saves-list ())
641         (restores-list ())
642         (skipping nil))
643     (declare (list saves-list restores-list))
644     (clear-bit-vector saves)
645     (clear-bit-vector restores)
646     (do-live-tns (tn (ir2-block-live-in block) block)
647       (when (and (sc-save-p (tn-sc tn))
648                  (not (eq (tn-kind tn) :component)))
649         (let ((num (tn-number tn)))
650           (setf (sbit restores num) 1)
651           (push tn restores-list))))
652
653     (do ((block block (ir2-block-prev block))
654          (prev nil block))
655         ((not (eq (ir2-block-block block) 1block))
656          (aver (not skipping))
657          (dolist (save saves-list)
658            (let ((start (ir2-block-start-vop prev)))
659              (save-if-necessary save start start)))
660          prev)
661       (do ((vop (ir2-block-last-vop block) (vop-prev vop)))
662           ((null vop))
663         (let ((info (vop-info vop)))
664           (case (vop-info-name info)
665             (allocate-frame
666              (aver skipping)
667              (setq skipping nil))
668             (note-environment-start
669              (aver (not skipping))
670              (dolist (save saves-list)
671                (save-if-necessary save (vop-next vop) vop))
672              (return-from optimized-emit-saves-block block)))
673
674           (unless skipping
675             (do ((write (vop-results vop) (tn-ref-across write)))
676                 ((null write))
677               (let* ((tn (tn-ref-tn write))
678                      (num (tn-number tn)))
679                 (unless (zerop (sbit restores num))
680                   (setf (sbit restores num) 0)
681                   (setq restores-list
682                         (delete tn restores-list :test #'eq)))
683                 (unless (zerop (sbit saves num))
684                   (setf (sbit saves num) 0)
685                   (save-if-necessary tn (vop-next vop) vop)
686                   (setq saves-list
687                         (delete tn saves-list :test #'eq))))))
688
689           (macrolet ((save-note-read (tn)
690                        `(let* ((tn ,tn)
691                                (num (tn-number tn)))
692                           (when (and (sc-save-p (tn-sc tn))
693                                      (zerop (sbit restores num))
694                                      (not (eq (tn-kind tn) :component)))
695                           (setf (sbit restores num) 1)
696                           (push tn restores-list)))))
697
698             (case (vop-info-save-p info)
699               ((t)
700                (dolist (tn restores-list)
701                  (restore-tn tn (vop-next vop) vop)
702                  (let ((num (tn-number tn)))
703                    (when (zerop (sbit saves num))
704                      (push tn saves-list)
705                      (setf (sbit saves num) 1))))
706                (setq restores-list nil)
707                (clear-bit-vector restores))
708               (:compute-only
709                (cond ((policy (vop-node vop) (= speed 3))
710                       (do-live-tns (tn (vop-save-set vop) block)
711                         (when (zerop (sbit restores (tn-number tn)))
712                           (note-spilled-tn tn vop))))
713                      (t
714                       (do-live-tns (tn (vop-save-set vop) block)
715                         (save-note-read tn))))))
716
717             (if (eq (vop-info-move-args info) :local-call)
718                 (setq skipping t)
719                 (do ((read (vop-args vop) (tn-ref-across read)))
720                     ((null read))
721                   (save-note-read (tn-ref-tn read))))))))))
722
723 ;;; This is like EMIT-SAVES, only different. We avoid redundant saving
724 ;;; within the block, and don't restore values that aren't used before
725 ;;; the next call. This function is just the top level loop over the
726 ;;; blocks in the component, which locates blocks that need saving
727 ;;; done.
728 (defun optimized-emit-saves (component)
729   (declare (type component component))
730   (let* ((gtn-count (1+ (ir2-component-global-tn-counter
731                          (component-info component))))
732          (saves (make-array gtn-count :element-type 'bit))
733          (restores (make-array gtn-count :element-type 'bit))
734          (block (ir2-block-prev (block-info (component-tail component))))
735          (head (block-info (component-head component))))
736     (loop
737       (when (eq block head) (return))
738       (when (do ((vop (ir2-block-start-vop block) (vop-next vop)))
739                 ((null vop) nil)
740               (when (eq (vop-info-save-p (vop-info vop)) t)
741                 (return t)))
742         (setq block (optimized-emit-saves-block block saves restores)))
743       (setq block (ir2-block-prev block)))))
744
745 ;;; Iterate over the normal TNs, finding the cost of packing on the
746 ;;; stack in units of the number of references. We count all
747 ;;; references as +1, and subtract out REGISTER-SAVE-PENALTY for each
748 ;;; place where we would have to save a register.
749 (defun assign-tn-costs (component)
750   (do-ir2-blocks (block component)
751     (do ((vop (ir2-block-start-vop block) (vop-next vop)))
752         ((null vop))
753       (when (eq (vop-info-save-p (vop-info vop)) t)
754         (do-live-tns (tn (vop-save-set vop) block)
755           (decf (tn-cost tn) *backend-register-save-penalty*)))))
756
757   (do ((tn (ir2-component-normal-tns (component-info component))
758            (tn-next tn)))
759       ((null tn))
760     (let ((cost (tn-cost tn)))
761       (declare (fixnum cost))
762       (do ((ref (tn-reads tn) (tn-ref-next ref)))
763           ((null ref))
764         (incf cost))
765       (do ((ref (tn-writes tn) (tn-ref-next ref)))
766           ((null ref))
767         (incf cost))
768       (setf (tn-cost tn) cost))))
769
770 ;;; Iterate over the normal TNs, storing the depth of the deepest loop
771 ;;; that the TN is used in TN-LOOP-DEPTH.
772 (defun assign-tn-depths (component)
773   (when *loop-analyze*
774     (do-ir2-blocks (block component)
775       (do ((vop (ir2-block-start-vop block)
776                 (vop-next vop)))
777           ((null vop))
778         (flet ((find-all-tns (head-fun)
779                  (collect ((tns))
780                    (do ((ref (funcall head-fun vop) (tn-ref-across ref)))
781                        ((null ref))
782                      (tns (tn-ref-tn ref)))
783                    (tns))))
784           (dolist (tn (nconc (find-all-tns #'vop-args)
785                              (find-all-tns #'vop-results)
786                              (find-all-tns #'vop-temps)
787                              ;; What does "references in this VOP
788                              ;; mean"? Probably something that isn't
789                              ;; useful in this context, since these
790                              ;; TN-REFs are linked with TN-REF-NEXT
791                              ;; instead of TN-REF-ACROSS. --JES
792                              ;; 2004-09-11
793                              ;; (find-all-tns #'vop-refs)
794                              ))
795             (setf (tn-loop-depth tn)
796                   (max (tn-loop-depth tn)
797                        (let* ((ir1-block (ir2-block-block (vop-block vop)))
798                               (loop (block-loop ir1-block)))
799                          (if loop
800                              (loop-depth loop)
801                              0))))))))))
802
803 \f
804 ;;;; load TN packing
805
806 ;;; These variables indicate the last location at which we computed
807 ;;; the Live-TNs. They hold the BLOCK and VOP values that were passed
808 ;;; to COMPUTE-LIVE-TNS.
809 (defvar *live-block*)
810 (defvar *live-vop*)
811
812 ;;; If we unpack some TNs, then we mark all affected blocks by
813 ;;; sticking them in this hash-table. This is initially null. We
814 ;;; create the hashtable if we do any unpacking.
815 (defvar *repack-blocks*)
816 (declaim (type list *repack-blocks*))
817
818 ;;; Set the LIVE-TNS vectors in all :FINITE SBs to represent the TNs
819 ;;; live at the end of BLOCK.
820 (defun init-live-tns (block)
821   (dolist (sb *backend-sb-list*)
822     (when (eq (sb-kind sb) :finite)
823       (fill (finite-sb-live-tns sb) nil)))
824
825   (do-live-tns (tn (ir2-block-live-in block) block)
826     (let* ((sc (tn-sc tn))
827            (sb (sc-sb sc)))
828       (when (eq (sb-kind sb) :finite)
829         (do ((offset (tn-offset tn) (1+ offset))
830              (end (+ (tn-offset tn) (sc-element-size sc))))
831             ((= offset end))
832           (declare (type index offset end))
833           (setf (svref (finite-sb-live-tns sb) offset) tn)))))
834
835   (setq *live-block* block)
836   (setq *live-vop* (ir2-block-last-vop block))
837
838   (values))
839
840 ;;; Set the LIVE-TNs in :FINITE SBs to represent the TNs live
841 ;;; immediately after the evaluation of VOP in BLOCK, excluding
842 ;;; results of the VOP. If VOP is null, then compute the live TNs at
843 ;;; the beginning of the block. Sequential calls on the same block
844 ;;; must be in reverse VOP order.
845 (defun compute-live-tns (block vop)
846   (declare (type ir2-block block) (type vop vop))
847   (unless (eq block *live-block*)
848     (init-live-tns block))
849
850   (do ((current *live-vop* (vop-prev current)))
851       ((eq current vop)
852        (do ((res (vop-results vop) (tn-ref-across res)))
853            ((null res))
854          (let* ((tn (tn-ref-tn res))
855                 (sc (tn-sc tn))
856                 (sb (sc-sb sc)))
857            (when (eq (sb-kind sb) :finite)
858              (do ((offset (tn-offset tn) (1+ offset))
859                   (end (+ (tn-offset tn) (sc-element-size sc))))
860                  ((= offset end))
861                (declare (type index offset end))
862                (setf (svref (finite-sb-live-tns sb) offset) nil))))))
863     (do ((ref (vop-refs current) (tn-ref-next-ref ref)))
864         ((null ref))
865       (let ((ltn (tn-ref-load-tn ref)))
866         (when ltn
867           (let* ((sc (tn-sc ltn))
868                  (sb (sc-sb sc)))
869             (when (eq (sb-kind sb) :finite)
870               (let ((tns (finite-sb-live-tns sb)))
871                 (do ((offset (tn-offset ltn) (1+ offset))
872                      (end (+ (tn-offset ltn) (sc-element-size sc))))
873                     ((= offset end))
874                   (declare (type index offset end))
875                   (aver (null (svref tns offset)))))))))
876
877       (let* ((tn (tn-ref-tn ref))
878              (sc (tn-sc tn))
879              (sb (sc-sb sc)))
880         (when (eq (sb-kind sb) :finite)
881           (let ((tns (finite-sb-live-tns sb)))
882             (do ((offset (tn-offset tn) (1+ offset))
883                  (end (+ (tn-offset tn) (sc-element-size sc))))
884                 ((= offset end))
885               (declare (type index offset end))
886               (if (tn-ref-write-p ref)
887                   (setf (svref tns offset) nil)
888                   (let ((old (svref tns offset)))
889                     (aver (or (null old) (eq old tn)))
890                     (setf (svref tns offset) tn)))))))))
891
892   (setq *live-vop* vop)
893   (values))
894
895 ;;; This is kind of like OFFSET-CONFLICTS-IN-SB, except that it uses
896 ;;; the VOP refs to determine whether a Load-TN for OP could be packed
897 ;;; in the specified location, disregarding conflicts with TNs not
898 ;;; referenced by this VOP. There is a conflict if either:
899 ;;;  1. The reference is a result, and the same location is either:
900 ;;;     -- Used by some other result.
901 ;;;     -- Used in any way after the reference (exclusive).
902 ;;;  2. The reference is an argument, and the same location is either:
903 ;;;     -- Used by some other argument.
904 ;;;     -- Used in any way before the reference (exclusive).
905 ;;;
906 ;;; In 1 (and 2) above, the first bullet corresponds to result-result
907 ;;; (and argument-argument) conflicts. We need this case because there
908 ;;; aren't any TN-REFs to represent the implicit reading of results or
909 ;;; writing of arguments.
910 ;;;
911 ;;; The second bullet corresponds conflicts with temporaries or between
912 ;;; arguments and results.
913 ;;;
914 ;;; We consider both the TN-REF-TN and the TN-REF-LOAD-TN (if any) to
915 ;;; be referenced simultaneously and in the same way. This causes
916 ;;; load-TNs to appear live to the beginning (or end) of the VOP, as
917 ;;; appropriate.
918 ;;;
919 ;;; We return a conflicting TN if there is a conflict.
920 (defun load-tn-offset-conflicts-in-sb (op sb offset)
921   (declare (type tn-ref op) (type finite-sb sb) (type index offset))
922   (aver (eq (sb-kind sb) :finite))
923   (let ((vop (tn-ref-vop op)))
924     (labels ((tn-overlaps (tn)
925                (let ((sc (tn-sc tn))
926                      (tn-offset (tn-offset tn)))
927                  (when (and (eq (sc-sb sc) sb)
928                             (<= tn-offset offset)
929                             (< offset
930                                (the index
931                                     (+ tn-offset (sc-element-size sc)))))
932                    tn)))
933              (same (ref)
934                (let ((tn (tn-ref-tn ref))
935                      (ltn (tn-ref-load-tn ref)))
936                  (or (tn-overlaps tn)
937                      (and ltn (tn-overlaps ltn)))))
938              (is-op (ops)
939                (do ((ops ops (tn-ref-across ops)))
940                    ((null ops) nil)
941                  (let ((found (same ops)))
942                    (when (and found (not (eq ops op)))
943                      (return found)))))
944              (is-ref (refs end)
945                (do ((refs refs (tn-ref-next-ref refs)))
946                    ((eq refs end) nil)
947                  (let ((found (same refs)))
948                  (when found (return found))))))
949       (declare (inline is-op is-ref tn-overlaps))
950       (if (tn-ref-write-p op)
951           (or (is-op (vop-results vop))
952               (is-ref (vop-refs vop) op))
953           (or (is-op (vop-args vop))
954               (is-ref (tn-ref-next-ref op) nil))))))
955
956 ;;; Iterate over all the elements in the SB that would be allocated by
957 ;;; allocating a TN in SC at Offset, checking for conflict with
958 ;;; load-TNs or other TNs (live in the LIVE-TNS, which must be set
959 ;;; up.) We also return true if there aren't enough locations after
960 ;;; Offset to hold a TN in SC. If Ignore-Live is true, then we ignore
961 ;;; the live-TNs, considering only references within Op's VOP.
962 ;;;
963 ;;; We return a conflicting TN, or :OVERFLOW if the TN won't fit.
964 (defun load-tn-conflicts-in-sc (op sc offset ignore-live)
965   (let* ((sb (sc-sb sc))
966          (size (finite-sb-current-size sb)))
967     (do ((i offset (1+ i))
968          (end (+ offset (sc-element-size sc))))
969         ((= i end) nil)
970       (declare (type index i end))
971       (let ((res (or (when (>= i size) :overflow)
972                      (and (not ignore-live)
973                           (svref (finite-sb-live-tns sb) i))
974                      (load-tn-offset-conflicts-in-sb op sb i))))
975         (when res (return res))))))
976
977 ;;; If a load-TN for OP is targeted to a legal location in SC, then
978 ;;; return the offset, otherwise return NIL. We see whether the target
979 ;;; of the operand is packed, and try that location. There isn't any
980 ;;; need to chain down the target path, since everything is packed
981 ;;; now.
982 ;;;
983 ;;; We require the target to be in SC (and not merely to overlap with
984 ;;; SC). This prevents SC information from being lost in load TNs (we
985 ;;; won't pack a load TN in ANY-REG when it is targeted to a
986 ;;; DESCRIPTOR-REG.) This shouldn't hurt the code as long as all
987 ;;; relevant overlapping SCs are allowed in the operand SC
988 ;;; restriction.
989 (defun find-load-tn-target (op sc)
990   (declare (inline member))
991   (let ((target (tn-ref-target op)))
992     (when target
993       (let* ((tn (tn-ref-tn target))
994              (loc (tn-offset tn)))
995         (if (and (eq (tn-sc tn) sc)
996                  (member (the index loc) (sc-locations sc))
997                  (not (load-tn-conflicts-in-sc op sc loc nil)))
998             loc
999             nil)))))
1000
1001 ;;; Select a legal location for a load TN for Op in SC. We just
1002 ;;; iterate over the SC's locations. If we can't find a legal
1003 ;;; location, return NIL.
1004 (defun select-load-tn-location (op sc)
1005   (declare (type tn-ref op) (type sc sc))
1006
1007   ;; Check any target location first.
1008   (let ((target (tn-ref-target op)))
1009     (when target
1010       (let* ((tn (tn-ref-tn target))
1011              (loc (tn-offset tn)))
1012         (when (and (eq (sc-sb sc) (sc-sb (tn-sc tn)))
1013                    (member (the index loc) (sc-locations sc))
1014                    (not (load-tn-conflicts-in-sc op sc loc nil)))
1015               (return-from select-load-tn-location loc)))))
1016
1017   (dolist (loc (sc-locations sc) nil)
1018     (unless (load-tn-conflicts-in-sc op sc loc nil)
1019       (return loc))))
1020
1021 (defevent unpack-tn "Unpacked a TN to satisfy operand SC restriction.")
1022
1023 ;;; Make TN's location the same as for its save TN (allocating a save
1024 ;;; TN if necessary.) Delete any save/restore code that has been
1025 ;;; emitted thus far. Mark all blocks containing references as needing
1026 ;;; to be repacked.
1027 (defun unpack-tn (tn)
1028   (event unpack-tn)
1029   (let ((stn (or (tn-save-tn tn)
1030                  (pack-save-tn tn))))
1031     (setf (tn-sc tn) (tn-sc stn))
1032     (setf (tn-offset tn) (tn-offset stn))
1033     (flet ((zot (refs)
1034              (do ((ref refs (tn-ref-next ref)))
1035                  ((null ref))
1036                (let ((vop (tn-ref-vop ref)))
1037                  (if (eq (vop-info-name (vop-info vop)) 'move-operand)
1038                      (delete-vop vop)
1039                      (pushnew (vop-block vop) *repack-blocks*))))))
1040       (zot (tn-reads tn))
1041       (zot (tn-writes tn))))
1042
1043   (values))
1044
1045 (defevent unpack-fallback "Unpacked some operand TN.")
1046
1047 ;;; This is called by PACK-LOAD-TN where there isn't any location free
1048 ;;; that we can pack into. What we do is move some live TN in one of
1049 ;;; the specified SCs to memory, then mark this block all blocks that
1050 ;;; reference the TN as needing repacking. If we succeed, we throw to
1051 ;;; UNPACKED-TN. If we fail, we return NIL.
1052 ;;;
1053 ;;; We can unpack any live TN that appears in the NORMAL-TNs list
1054 ;;; (isn't wired or restricted.) We prefer to unpack TNs that are not
1055 ;;; used by the VOP. If we can't find any such TN, then we unpack some
1056 ;;; argument or result TN. The only way we can fail is if all
1057 ;;; locations in SC are used by load-TNs or temporaries in VOP.
1058 (defun unpack-for-load-tn (sc op)
1059   (declare (type sc sc) (type tn-ref op))
1060   (let ((sb (sc-sb sc))
1061         (normal-tns (ir2-component-normal-tns
1062                      (component-info *component-being-compiled*)))
1063         (node (vop-node (tn-ref-vop op)))
1064         (fallback nil))
1065     (flet ((unpack-em (victims)
1066              (pushnew (vop-block (tn-ref-vop op)) *repack-blocks*)
1067              (dolist (victim victims)
1068                (event unpack-tn node)
1069                (unpack-tn victim))
1070              (throw 'unpacked-tn nil)))
1071       (dolist (loc (sc-locations sc))
1072         (declare (type index loc))
1073         (block SKIP
1074           (collect ((victims nil adjoin))
1075             (do ((i loc (1+ i))
1076                  (end (+ loc (sc-element-size sc))))
1077                 ((= i end))
1078               (declare (type index i end))
1079               (let ((victim (svref (finite-sb-live-tns sb) i)))
1080                 (when victim
1081                   (unless (find-in #'tn-next victim normal-tns)
1082                     (return-from SKIP))
1083                   (victims victim))))
1084
1085             (let ((conf (load-tn-conflicts-in-sc op sc loc t)))
1086               (cond ((not conf)
1087                      (unpack-em (victims)))
1088                     ((eq conf :overflow))
1089                     ((not fallback)
1090                      (cond ((find conf (victims))
1091                             (setq fallback (victims)))
1092                            ((find-in #'tn-next conf normal-tns)
1093                             (setq fallback (list conf))))))))))
1094
1095       (when fallback
1096         (event unpack-fallback node)
1097         (unpack-em fallback))))
1098
1099   nil)
1100
1101 ;;; Try to pack a load TN in the SCs indicated by Load-SCs. If we run
1102 ;;; out of SCs, then we unpack some TN and try again. We return the
1103 ;;; packed load TN.
1104 ;;;
1105 ;;; Note: we allow a Load-TN to be packed in the target location even
1106 ;;; if that location is in a SC not allowed by the primitive type.
1107 ;;; (The SC must still be allowed by the operand restriction.) This
1108 ;;; makes move VOPs more efficient, since we won't do a move from the
1109 ;;; stack into a non-descriptor any-reg though a descriptor argument
1110 ;;; load-TN. This does give targeting some real semantics, making it
1111 ;;; not a pure advisory to pack. It allows pack to do some packing it
1112 ;;; wouldn't have done before.
1113 (defun pack-load-tn (load-scs op)
1114   (declare (type sc-vector load-scs) (type tn-ref op))
1115   (let ((vop (tn-ref-vop op)))
1116     (compute-live-tns (vop-block vop) vop))
1117
1118   (let* ((tn (tn-ref-tn op))
1119          (ptype (tn-primitive-type tn))
1120          (scs (svref load-scs (sc-number (tn-sc tn)))))
1121     (let ((current-scs scs)
1122           (allowed ()))
1123       (loop
1124         (cond
1125          ((null current-scs)
1126           (unless allowed
1127             (no-load-scs-allowed-by-primitive-type-error op))
1128           (dolist (sc allowed)
1129             (unpack-for-load-tn sc op))
1130           (failed-to-pack-load-tn-error allowed op))
1131         (t
1132          (let* ((sc (svref *backend-sc-numbers* (pop current-scs)))
1133                 (target (find-load-tn-target op sc)))
1134            (when (or target (sc-allowed-by-primitive-type sc ptype))
1135              (let ((loc (or target
1136                             (select-load-tn-location op sc))))
1137                (when loc
1138                  (let ((res (make-tn 0 :load nil sc)))
1139                    (setf (tn-offset res) loc)
1140                    (return res))))
1141              (push sc allowed)))))))))
1142
1143 ;;; Scan a list of load-SCs vectors and a list of TN-REFS threaded by
1144 ;;; TN-REF-ACROSS. When we find a reference whose TN doesn't satisfy
1145 ;;; the restriction, we pack a Load-TN and load the operand into it.
1146 ;;; If a load-tn has already been allocated, we can assume that the
1147 ;;; restriction is satisfied.
1148 #!-sb-fluid (declaim (inline check-operand-restrictions))
1149 (defun check-operand-restrictions (scs ops)
1150   (declare (list scs) (type (or tn-ref null) ops))
1151
1152   ;; Check the targeted operands first.
1153   (do ((scs scs (cdr scs))
1154        (op ops (tn-ref-across op)))
1155       ((null scs))
1156       (let ((target (tn-ref-target op)))
1157         (when target
1158            (let* ((load-tn (tn-ref-load-tn op))
1159                   (load-scs (svref (car scs)
1160                                    (sc-number
1161                                     (tn-sc (or load-tn (tn-ref-tn op)))))))
1162              (if load-tn
1163                  (aver (eq load-scs t))
1164                (unless (eq load-scs t)
1165                        (setf (tn-ref-load-tn op)
1166                              (pack-load-tn (car scs) op))))))))
1167
1168   (do ((scs scs (cdr scs))
1169        (op ops (tn-ref-across op)))
1170       ((null scs))
1171       (let ((target (tn-ref-target op)))
1172         (unless target
1173            (let* ((load-tn (tn-ref-load-tn op))
1174                   (load-scs (svref (car scs)
1175                                    (sc-number
1176                                     (tn-sc (or load-tn (tn-ref-tn op)))))))
1177              (if load-tn
1178                  (aver (eq load-scs t))
1179                (unless (eq load-scs t)
1180                        (setf (tn-ref-load-tn op)
1181                              (pack-load-tn (car scs) op))))))))
1182
1183   (values))
1184
1185 ;;; Scan the VOPs in BLOCK, looking for operands whose SC restrictions
1186 ;;; aren't satisfied. We do the results first, since they are
1187 ;;; evaluated later, and our conflict analysis is a backward scan.
1188 (defun pack-load-tns (block)
1189   (catch 'unpacked-tn
1190     (let ((*live-block* nil)
1191           (*live-vop* nil))
1192       (do ((vop (ir2-block-last-vop block) (vop-prev vop)))
1193           ((null vop))
1194         (let ((info (vop-info vop)))
1195           (check-operand-restrictions (vop-info-result-load-scs info)
1196                                       (vop-results vop))
1197           (check-operand-restrictions (vop-info-arg-load-scs info)
1198                                       (vop-args vop))))))
1199   (values))
1200 \f
1201 ;;;; targeting
1202
1203 ;;; Link the TN-REFS READ and WRITE together using the TN-REF-TARGET
1204 ;;; when this seems like a good idea. Currently we always do, as this
1205 ;;; increases the success of load-TN targeting.
1206 (defun target-if-desirable (read write)
1207   (declare (type tn-ref read write))
1208   ;; As per the comments at the definition of TN-REF-TARGET, read and
1209   ;; write refs are always paired, with TARGET in the read pointing to
1210   ;; the write and vice versa.
1211   (aver (eq (tn-ref-write-p read)
1212             (not (tn-ref-write-p write))))
1213   (setf (tn-ref-target read) write)
1214   (setf (tn-ref-target write) read))
1215
1216 ;;; If TN can be packed into SC so as to honor a preference to TARGET,
1217 ;;; then return the offset to pack at, otherwise return NIL. TARGET
1218 ;;; must be already packed.
1219 (defun check-ok-target (target tn sc)
1220   (declare (type tn target tn) (type sc sc) (inline member))
1221   (let* ((loc (tn-offset target))
1222          (target-sc (tn-sc target))
1223          (target-sb (sc-sb target-sc)))
1224     (declare (type index loc))
1225     ;; We can honor a preference if:
1226     ;; -- TARGET's location is in SC's locations.
1227     ;; -- The element sizes of the two SCs are the same.
1228     ;; -- TN doesn't conflict with target's location.
1229     (if (and (eq target-sb (sc-sb sc))
1230              (or (eq (sb-kind target-sb) :unbounded)
1231                  (member loc (sc-locations sc)))
1232              (= (sc-element-size target-sc) (sc-element-size sc))
1233              (not (conflicts-in-sc tn sc loc))
1234              (zerop (mod loc (sc-alignment sc))))
1235         loc
1236         nil)))
1237
1238 ;;; Scan along the target path from TN, looking at readers or writers.
1239 ;;; When we find a packed TN, return CHECK-OK-TARGET of that TN. If
1240 ;;; there is no target, or if the TN has multiple readers (writers),
1241 ;;; then we return NIL. We also always return NIL after 10 iterations
1242 ;;; to get around potential circularity problems.
1243 ;;;
1244 ;;; FIXME: (30 minutes of reverse engineering?) It'd be nice to
1245 ;;; rewrite the header comment here to explain the interface and its
1246 ;;; motivation, and move remarks about implementation details (like
1247 ;;; 10!) inside.
1248 (defun find-ok-target-offset (tn sc)
1249   (declare (type tn tn) (type sc sc))
1250   (flet ((frob-slot (slot-fun)
1251            (declare (type function slot-fun))
1252            (let ((count 10)
1253                  (current tn))
1254              (declare (type index count))
1255              (loop
1256               (let ((refs (funcall slot-fun current)))
1257                 (unless (and (plusp count)
1258                              refs
1259                              (not (tn-ref-next refs)))
1260                   (return nil))
1261                 (let ((target (tn-ref-target refs)))
1262                   (unless target (return nil))
1263                   (setq current (tn-ref-tn target))
1264                   (when (tn-offset current)
1265                     (return (check-ok-target current tn sc)))
1266                   (decf count)))))))
1267     (declare (inline frob-slot)) ; until DYNAMIC-EXTENT works
1268     (or (frob-slot #'tn-reads)
1269         (frob-slot #'tn-writes))))
1270 \f
1271 ;;;; location selection
1272
1273 ;;; Select some location for TN in SC, returning the offset if we
1274 ;;; succeed, and NIL if we fail.
1275 ;;;
1276 ;;; For :UNBOUNDED SCs just find the smallest correctly aligned offset
1277 ;;; where the TN doesn't conflict with the TNs that have already been
1278 ;;; packed. For :FINITE SCs try to pack the TN into the most heavily
1279 ;;; used locations first (as estimated in FIND-LOCATION-USAGE).
1280 ;;;
1281 ;;; Historically SELECT-LOCATION tried did the opposite and tried to
1282 ;;; distribute the TNs evenly across the available locations. At least
1283 ;;; on register-starved architectures (x86) this seems to be a bad
1284 ;;; strategy. -- JES 2004-09-11
1285 (defun select-location (tn sc &key use-reserved-locs optimize)
1286   (declare (type tn tn) (type sc sc) (inline member))
1287   (let* ((sb (sc-sb sc))
1288          (element-size (sc-element-size sc))
1289          (alignment (sc-alignment sc))
1290          (align-mask (1- alignment))
1291          (size (finite-sb-current-size sb)))
1292     (flet ((attempt-location (start-offset)
1293              (dotimes (i element-size
1294                        (return-from select-location start-offset))
1295                (declare (type index i))
1296                (let ((offset (+ start-offset i)))
1297                  (when (offset-conflicts-in-sb tn sb offset)
1298                    (return (logandc2 (the index (+ (the index (1+ offset))
1299                                                    align-mask))
1300                                      align-mask)))))))
1301       (if (eq (sb-kind sb) :unbounded)
1302           (loop with offset = 0
1303                 until (> (+ offset element-size) size) do
1304                 (setf offset (attempt-location offset)))
1305           (let ((locations (sc-locations sc)))
1306             (when optimize
1307               (setf locations
1308                     (stable-sort (copy-list locations) #'>
1309                                  :key (lambda (location-offset)
1310                                         (loop for offset from location-offset
1311                                               repeat element-size
1312                                               maximize (svref
1313                                                         (finite-sb-always-live-count sb)
1314                                                         offset))))))
1315             (dolist (offset locations)
1316               (when (or use-reserved-locs
1317                         (not (member offset
1318                                      (sc-reserve-locations sc))))
1319                 (attempt-location offset))))))))
1320
1321 ;;; If a save TN, return the saved TN, otherwise return TN. This is
1322 ;;; useful for getting the conflicts of a TN that might be a save TN.
1323 (defun original-tn (tn)
1324   (declare (type tn tn))
1325   (if (member (tn-kind tn) '(:save :save-once :specified-save))
1326       (tn-save-tn tn)
1327       tn))
1328 \f
1329 ;;;; pack interface
1330
1331 ;;; Attempt to pack TN in all possible SCs, first in the SC chosen by
1332 ;;; representation selection, then in the alternate SCs in the order
1333 ;;; they were specified in the SC definition. If the TN-COST is
1334 ;;; negative, then we don't attempt to pack in SCs that must be saved.
1335 ;;; If Restricted, then we can only pack in TN-SC, not in any
1336 ;;; Alternate-SCs.
1337 ;;;
1338 ;;; If we are attempting to pack in the SC of the save TN for a TN
1339 ;;; with a :SPECIFIED-SAVE TN, then we pack in that location, instead
1340 ;;; of allocating a new stack location.
1341 (defun pack-tn (tn restricted optimize)
1342   (declare (type tn tn))
1343   (let* ((original (original-tn tn))
1344          (fsc (tn-sc tn))
1345          (alternates (unless restricted (sc-alternate-scs fsc)))
1346          (save (tn-save-tn tn))
1347          (specified-save-sc
1348           (when (and save
1349                      (eq (tn-kind save) :specified-save))
1350             (tn-sc save))))
1351     (do ((sc fsc (pop alternates)))
1352         ((null sc)
1353          (failed-to-pack-error tn restricted))
1354       (when (eq sc specified-save-sc)
1355         (unless (tn-offset save)
1356           (pack-tn save nil optimize))
1357         (setf (tn-offset tn) (tn-offset save))
1358         (setf (tn-sc tn) (tn-sc save))
1359         (return))
1360       (when (or restricted
1361                 (not (and (minusp (tn-cost tn)) (sc-save-p sc))))
1362         (let ((loc (or (find-ok-target-offset original sc)
1363                        (select-location original sc)
1364                        (and restricted
1365                             (select-location original sc :use-reserved-locs t))
1366                        (when (eq (sb-kind (sc-sb sc)) :unbounded)
1367                          (grow-sc sc)
1368                          (or (select-location original sc)
1369                              (error "failed to pack after growing SC?"))))))
1370           (when loc
1371             (add-location-conflicts original sc loc optimize)
1372             (setf (tn-sc tn) sc)
1373             (setf (tn-offset tn) loc)
1374             (return))))))
1375   (values))
1376
1377 ;;; Pack a wired TN, checking that the offset is in bounds for the SB,
1378 ;;; and that the TN doesn't conflict with some other TN already packed
1379 ;;; in that location. If the TN is wired to a location beyond the end
1380 ;;; of a :UNBOUNDED SB, then grow the SB enough to hold the TN.
1381 ;;;
1382 ;;; ### Checking for conflicts is disabled for :SPECIFIED-SAVE TNs.
1383 ;;; This is kind of a hack to make specifying wired stack save
1384 ;;; locations for local call arguments (such as OLD-FP) work, since
1385 ;;; the caller and callee OLD-FP save locations may conflict when the
1386 ;;; save locations don't really (due to being in different frames.)
1387 (defun pack-wired-tn (tn optimize)
1388   (declare (type tn tn))
1389   (let* ((sc (tn-sc tn))
1390          (sb (sc-sb sc))
1391          (offset (tn-offset tn))
1392          (end (+ offset (sc-element-size sc)))
1393          (original (original-tn tn)))
1394     (when (> end (finite-sb-current-size sb))
1395       (unless (eq (sb-kind sb) :unbounded)
1396         (error "~S is wired to a location that is out of bounds." tn))
1397       (grow-sc sc end))
1398
1399     ;; For non-x86 ports the presence of a save-tn associated with a
1400     ;; tn is used to identify the old-fp and return-pc tns. It depends
1401     ;; on the old-fp and return-pc being passed in registers.
1402     #!-(or x86 x86-64)
1403     (when (and (not (eq (tn-kind tn) :specified-save))
1404                (conflicts-in-sc original sc offset))
1405       (error "~S is wired to a location that it conflicts with." tn))
1406
1407     ;; Use the above check, but only print a verbose warning. This can
1408     ;; be helpful for debugging the x86 port.
1409     #+nil
1410     (when (and (not (eq (tn-kind tn) :specified-save))
1411                (conflicts-in-sc original sc offset))
1412           (format t "~&* Pack-wired-tn possible conflict:~%  ~
1413                      tn: ~S; tn-kind: ~S~%  ~
1414                      sc: ~S~%  ~
1415                      sb: ~S; sb-name: ~S; sb-kind: ~S~%  ~
1416                      offset: ~S; end: ~S~%  ~
1417                      original ~S~%  ~
1418                      tn-save-tn: ~S; tn-kind of tn-save-tn: ~S~%"
1419                   tn (tn-kind tn) sc
1420                   sb (sb-name sb) (sb-kind sb)
1421                   offset end
1422                   original
1423                   (tn-save-tn tn) (tn-kind (tn-save-tn tn))))
1424
1425     ;; On the x86 ports the old-fp and return-pc are often passed on
1426     ;; the stack so the above hack for the other ports does not always
1427     ;; work. Here the old-fp and return-pc tns are identified by being
1428     ;; on the stack in their standard save locations.
1429     #!+(or x86 x86-64)
1430     (when (and (not (eq (tn-kind tn) :specified-save))
1431                (not (and (string= (sb-name sb) "STACK")
1432                          (or (= offset 0)
1433                              (= offset 1))))
1434                (conflicts-in-sc original sc offset))
1435       (error "~S is wired to a location that it conflicts with." tn))
1436
1437     (add-location-conflicts original sc offset optimize)))
1438
1439 (defevent repack-block "Repacked a block due to TN unpacking.")
1440
1441 ;;; KLUDGE: Prior to SBCL version 0.8.9.xx, this function was known as
1442 ;;; PACK-BEFORE-GC-HOOK, but was non-functional since approximately
1443 ;;; version 0.8.3.xx since the removal of GC hooks from the system.
1444 ;;; This currently (as of 2004-04-12) runs now after every call to
1445 ;;; PACK, rather than -- as was originally intended -- once per GC
1446 ;;; cycle; this is probably non-optimal, and might require tuning,
1447 ;;; maybe to be called when the data structures exceed a certain size,
1448 ;;; or maybe once every N times.  The KLUDGE is that this rewrite has
1449 ;;; done nothing to improve the reentrance or threadsafety of the
1450 ;;; compiler; it still fails to be callable from several threads at
1451 ;;; the same time.
1452 ;;;
1453 ;;; Brief experiments indicate that during a compilation cycle this
1454 ;;; causes about 10% more consing, and takes about 1%-2% more time.
1455 ;;;
1456 ;;; -- CSR, 2004-04-12
1457 (defun clean-up-pack-structures ()
1458   (dolist (sb *backend-sb-list*)
1459     (unless (eq (sb-kind sb) :non-packed)
1460       (let ((size (sb-size sb)))
1461         (fill (finite-sb-always-live sb) nil)
1462         (setf (finite-sb-always-live sb)
1463               (make-array size
1464                           :initial-element
1465                           #-sb-xc #*
1466                           ;; The cross-compiler isn't very good at
1467                           ;; dumping specialized arrays, so we delay
1468                           ;; construction of this SIMPLE-BIT-VECTOR
1469                           ;; until runtime.
1470                           #+sb-xc (make-array 0 :element-type 'bit)))
1471         (setf (finite-sb-always-live-count sb)
1472               (make-array size
1473                           :initial-element
1474                           #-sb-xc #*
1475                           ;; Ibid
1476                           #+sb-xc (make-array 0 :element-type 'fixnum)))
1477
1478         (fill (finite-sb-conflicts sb) nil)
1479         (setf (finite-sb-conflicts sb)
1480               (make-array size :initial-element '#()))
1481
1482         (fill (finite-sb-live-tns sb) nil)
1483         (setf (finite-sb-live-tns sb)
1484               (make-array size :initial-element nil))))))
1485
1486 (defun pack (component)
1487   (unwind-protect
1488        (let ((optimize nil)
1489              (2comp (component-info component)))
1490          (init-sb-vectors component)
1491
1492          ;; Determine whether we want to do more expensive packing by
1493          ;; checking whether any blocks in the component have (> SPEED
1494          ;; COMPILE-SPEED).
1495          ;;
1496          ;; FIXME: This means that a declaration can have a minor
1497          ;; effect even outside its scope, and as the packing is done
1498          ;; component-globally it'd be tricky to use strict scoping. I
1499          ;; think this is still acceptable since it's just a tradeoff
1500          ;; between compilation speed and allocation quality and
1501          ;; doesn't affect the semantics of the generated code in any
1502          ;; way. -- JES 2004-10-06
1503          (do-ir2-blocks (block component)
1504            (when (policy (block-last (ir2-block-block block))
1505                          (> speed compilation-speed))
1506              (setf optimize t)
1507              (return)))
1508
1509          ;; Call the target functions.
1510          (do-ir2-blocks (block component)
1511            (do ((vop (ir2-block-start-vop block) (vop-next vop)))
1512                ((null vop))
1513              (let ((target-fun (vop-info-target-fun (vop-info vop))))
1514                (when target-fun
1515                  (funcall target-fun vop)))))
1516
1517          ;; Pack wired TNs first.
1518          (do ((tn (ir2-component-wired-tns 2comp) (tn-next tn)))
1519              ((null tn))
1520            (pack-wired-tn tn optimize))
1521
1522          ;; Pack restricted component TNs.
1523          (do ((tn (ir2-component-restricted-tns 2comp) (tn-next tn)))
1524              ((null tn))
1525            (when (eq (tn-kind tn) :component)
1526              (pack-tn tn t optimize)))
1527
1528          ;; Pack other restricted TNs.
1529          (do ((tn (ir2-component-restricted-tns 2comp) (tn-next tn)))
1530              ((null tn))
1531            (unless (tn-offset tn)
1532              (pack-tn tn t optimize)))
1533
1534          ;; Assign costs to normal TNs so we know which ones should
1535          ;; always be packed on the stack.
1536          (when *pack-assign-costs*
1537            (assign-tn-costs component)
1538            (assign-tn-depths component))
1539
1540          ;; Allocate normal TNs, starting with the TNs that are used
1541          ;; in deep loops.
1542          (collect ((tns))
1543            (do-ir2-blocks (block component)
1544              (let ((ltns (ir2-block-local-tns block)))
1545                (do ((i (1- (ir2-block-local-tn-count block)) (1- i)))
1546                    ((minusp i))
1547                  (declare (fixnum i))
1548                  (let ((tn (svref ltns i)))
1549                    (unless (or (null tn)
1550                                (eq tn :more)
1551                                (tn-offset tn))
1552                      ;; If loop analysis has been disabled we might as
1553                      ;; well revert to the old behaviour of just
1554                      ;; packing TNs linearly as they appear.
1555                      (unless *loop-analyze*
1556                        (pack-tn tn nil optimize))
1557                      (tns tn))))))
1558            (dolist (tn (stable-sort (tns)
1559                                     (lambda (a b)
1560                                       (cond
1561                                         ((> (tn-loop-depth a)
1562                                             (tn-loop-depth b))
1563                                          t)
1564                                         ((= (tn-loop-depth a)
1565                                             (tn-loop-depth b))
1566                                          (> (tn-cost a) (tn-cost b)))
1567                                         (t nil)))))
1568              (unless (tn-offset tn)
1569                (pack-tn tn nil optimize))))
1570
1571          ;; Pack any leftover normal TNs. This is to deal with :MORE TNs,
1572          ;; which could possibly not appear in any local TN map.
1573          (do ((tn (ir2-component-normal-tns 2comp) (tn-next tn)))
1574              ((null tn))
1575            (unless (tn-offset tn)
1576              (pack-tn tn nil optimize)))
1577
1578          ;; Do load TN packing and emit saves.
1579          (let ((*repack-blocks* nil))
1580            (cond ((and optimize *pack-optimize-saves*)
1581                   (optimized-emit-saves component)
1582                   (do-ir2-blocks (block component)
1583                     (pack-load-tns block)))
1584                  (t
1585                   (do-ir2-blocks (block component)
1586                     (emit-saves block)
1587                     (pack-load-tns block))))
1588            (loop
1589               (unless *repack-blocks* (return))
1590               (let ((orpb *repack-blocks*))
1591                 (setq *repack-blocks* nil)
1592                 (dolist (block orpb)
1593                   (event repack-block)
1594                   (pack-load-tns block)))))
1595
1596          (values))
1597     (clean-up-pack-structures)))