Changeset 16502


Ignore:
Timestamp:
Aug 13, 2015, 5:04:10 AM (4 years ago)
Author:
gb
Message:

temp5 a temp reg again.
arg_w an arg reg sometimes
Don't bailout on assignment/multiple definitions

Location:
branches/lscan/source
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branches/lscan/source/compiler/X86/X8664/x8664-arch.lisp

    r16336 r16502  
    194194(defx86reg arg_x.w r8w)
    195195(defx86reg arg_x.b r8b)
     196
     197(defx86reg arg_w r9)
     198(defx86reg arg_w.l r9d)
     199(defx86reg arg_w.w r9w)
     200(defx86reg arg_w.b r9b)
    196201
    197202(defx86reg temp1 r9)
  • branches/lscan/source/compiler/X86/X8664/x8664-vinsns.lisp

    r16497 r16502  
    21432143  (pushq (:$b x8664::reserved-frame-marker))
    21442144  (pushq (:$b x8664::reserved-frame-marker)))
     2145
     2146(define-x8664-vinsn (pop-return-address-into-reserved-frame) (()
     2147                                                              ())
     2148  (popq (:@ 16 (:%q x8664::rsp))))
     2149 
    21452150
    21462151
  • branches/lscan/source/compiler/X86/x862.lisp

    r16501 r16502  
    12991299          nil)))))
    13001300
     1301
     1302
     1303
     1304
     1305(defun x862-simple-optional-entry (seg rev-fixed-args opt-args)
     1306  (with-x86-local-vinsn-macros (seg)
     1307    (let* ((min (length rev-fixed-args))
     1308           (nopt (length opt-args))
     1309           (max (+ min nopt))
     1310           (args (append (reverse rev-fixed-args) opt-args))
     1311           (nargs (length args)))
     1312      (if (and (< nargs 4) (= nopt 1))
     1313        (progn
     1314          (setq *x862-incoming-args-on-stack* 0)
     1315         (if (eql min 0)
     1316           (! check-max-nargs max)
     1317           (! check-min-max-nargs min max))
     1318         (! save-lisp-context-no-stack-args)
     1319         (! default-1-arg min)
     1320         (let*  ((nspilled 0))
     1321           (setq *x862-vstack* (ash nspilled 3)))
     1322         (! reserve-spill-area)
     1323         (! save-nfp)
     1324         (do* ((nargs (length args) (1- nargs)))
     1325             
     1326              ((null args) ())
     1327           (declare (type (signed-byte 16) nargs ))
     1328           (let* ((var (pop args))
     1329                  (reg (?)))
     1330             (cond ((= nargs 3)
     1331                    (! copy-gpr reg ($ x8664::arg_x)))
     1332                   
     1333                   ((= nargs 2)
     1334                    (! copy-gpr reg  ($ x8664::arg_y)))
     1335                   
     1336                   ((= nargs 1)
     1337                    (! copy-gpr reg ($ x8664::arg_z))))
     1338             (setf (var-lreg var) reg)))
     1339
     1340         
     1341         t)))))
     1342         
     1343(defun x862-fixed-args-entry (seg rev-fixed-args)
     1344  (with-x86-local-vinsn-macros (seg)
     1345    (let* ((args (reverse rev-fixed-args))
     1346           (nargs (length args)))
     1347      (cond ((<= nargs 4)
     1348             (unless *x862-reckless*
     1349               (! check-exact-nargs nargs))
     1350             (when (= nargs 4)
     1351               (! pop-return-address-into-reserved-frame)
     1352               (! vpop-register ($ x8664::arg_w))
     1353               (! vstack-discard 1))
     1354
     1355             (! save-lisp-context-no-stack-args)
     1356             (setq *x862-incoming-args-on-stack* 0)
     1357             (let*  ((nspilled 0))
     1358               (declare (fixnum nspilled))
     1359               (setq *x862-vstack* (ash nspilled 3)))
     1360     
     1361             (@ (setq *x862-fixed-self-tail-call-label* (backend-get-next-label)))
     1362
     1363             (! reserve-spill-area)
     1364             (! save-nfp)
     1365             (do* ((nargs (length args) (1- nargs)))
     1366
     1367                  ((null args) ())
     1368               (declare (type (signed-byte 16)  nargs ))
     1369               (let* ((var (pop args))
     1370                      (reg (?)))
     1371             
     1372                 (cond ((= nargs 4)               
     1373                        (! copy-gpr reg ($ x8664::arg_w)))
     1374                         
     1375                       ((= nargs 3)
     1376                        (! copy-gpr reg ($ x8664::arg_x)))
     1377
     1378                       ((= nargs 2)
     1379                        (! copy-gpr reg  ($ x8664::arg_y)))
     1380
     1381                       ((= nargs 1)
     1382                        (! copy-gpr reg ($ x8664::arg_z))))
     1383                 (push var *x862-tail-arg-vars*)
     1384                 (setf (var-lreg var) reg)))
     1385             
     1386
     1387             t)
     1388       ))))
     1389
    13011390;; arg oount has been checked, context has been saved, &optionals defaulted.
    1302 
    1303 (defun x862-simple-args-entry (seg rev-fixed-args min max)
    1304   (with-x86-local-vinsn-macros (seg)
    1305     (let* ((fixed (eql min max))
    1306            (nopt (- max min))
    1307            (args (reverse rev-fixed-args))
    1308            (nargs (length args)))
    1309       (if fixed
    1310         (unless *x862-reckless*
    1311           (! check-exact-nargs nargs))
    1312         (progn
    1313           (if (eql min 0)
    1314             (! check-max-nargs max)
    1315             (! check-min-max-nargs min max))))
    1316       (if fixed
    1317         (if (<= max  *x862-target-num-arg-regs*) ; caller didn't vpush anything
    1318           (! save-lisp-context-no-stack-args)
    1319           (let* ((offset (* (the fixnum (- max *x862-target-num-arg-regs*)) *x862-target-node-size*)))
    1320             (declare (fixnum offset))
    1321             (! save-lisp-context-offset offset)))
    1322         (if (> min *x862-target-num-arg-regs*)
    1323           (! save-lisp-context-in-frame)
    1324           (if (<= max *x862-target-num-arg-regs*)
    1325             (! save-lisp-context-no-stack-args)
    1326             (! save-lisp-context-variable-arg-count))))
    1327       (unless fixed
    1328         (if (= nopt 1)
    1329           (! default-1-arg min)
    1330           (if (= nopt 2)
    1331             (! default-2-args min)
    1332             (! default-3-args min))))
    1333       (setq *x862-incoming-args-on-stack* (max (- max *x862-target-num-arg-regs*) 0))
    1334       (let*  ((nspilled *x862-incoming-args-on-stack*))
    1335         (declare (fixnum nspilled))
    1336         (setq *x862-vstack* (ash nspilled 3)))
    1337      
    1338 
    1339       (! reserve-spill-area)
    1340       (! save-nfp)
    1341       (if fixed  (@ (setq *x862-fixed-self-tail-call-label* (backend-get-next-label))))
    1342       (do* ((offset 0 (1+ offset))
    1343             (nargs (length args) (1- nargs)))
    1344 
    1345            ((null args) ())
    1346         (declare (type (signed-byte 16) offset nargs ))
    1347         (let* ((var (pop args))
    1348                (reg (?)))
    1349              
    1350           (cond ((> nargs 3)
    1351                  (setf (lreg-spill-offset reg) offset
    1352                        (lreg-flags reg)
    1353                        (logior lreg-flag-spill lreg-flag-pre-spill))
    1354                  )
    1355 
    1356                          
    1357                 ((= nargs 3)
    1358                  (! copy-gpr reg ($ x8664::arg_x)))
    1359 
    1360                 ((= nargs 2)
    1361                  (! copy-gpr reg  ($ x8664::arg_y)))
    1362 
    1363                 ((= nargs 1)
    1364                  (! copy-gpr reg ($ x8664::arg_z))))
    1365           (if fixed (push var *x862-tail-arg-vars*))
    1366           (setf (var-lreg var) reg)))
    1367 
    1368       )))
    13691391
    13701392;;; nargs has been validated, arguments defaulted and canonicalized.
     
    58065828        (let* ((offset (ash vloc -3)))
    58075829          (when (< offset *x862-incoming-args-on-stack*)
     5830            (break)
    58085831            (setf (lreg-spill-offset reg) offset
    58095832                  (lreg-flags reg)
     
    74477470  (with-x86-local-vinsn-macros (seg vreg xfer)
    74487471    (let* ((stack-consed-rest nil)
    7449            (handled-lambda nil)
     7472           (handled-simple-lambda nil)
    74507473           (next-method-var-scope-info nil)
    74517474           (lexprp (if (consp rest) (progn (setq rest (car rest)) t)))
     
    75157538               (max-args (unless (or rest keys) (+ num-fixed num-opt))))
    75167539          (if (not (or opt rest keys))
    7517             ;;(setq arg-regs (x862-req-nargs-entry seg rev-fixed))
    7518             (if *backend-use-linear-scan*
    7519               (progn
    7520                 (setq handled-lambda t)
    7521                 (x862-simple-args-entry seg rev-fixed num-fixed num-fixed ))
    7522               (setq arg-regs (x862-req-nargs-entry seg rev-fixed)))
     7540            (or (and  *backend-use-linear-scan* (setq handled-simple-lambda (x862-fixed-args-entry seg rev-fixed)))
     7541                (setq arg-regs (x862-req-nargs-entry seg rev-fixed)))
    75237542            (if (and (not (or hardopt rest keys))
    75247543                     (<= (+ num-fixed num-opt) *x862-target-num-arg-regs*))
    7525               (if *backend-use-linear-scan*
    7526                 (progn
    7527                   (setq handled-lambda t)
    7528                   (x862-simple-args-entry seg (append rev-opt rev-fixed) num-fixed max-args ))
     7544              (if  *backend-use-linear-scan*
     7545                (setq handled-simple-lambda (x862-simple-optional-entry seg  rev-fixed  rev-opt))
     7546
    75297547                (setq arg-regs (x862-simple-opt-entry seg rev-opt rev-fixed)))
     7548
    75307549              (progn
    75317550
    7532                 (when (and *backend-use-linear-scan* (not handled-lambda))
    7533                   (linear-scan-bailout))
     7551                (when (and *backend-use-linear-scan* (not handled-simple-lambda))
     7552                  (linear-scan-bailout 'foo))
    75347553                ;; From now on, the runtime assumes that all
    75357554                ;; incoming arguments are on the stack, either because
     
    75527571                ;; If there were &optional args, initialize their values
    75537572                ;; to NIL.  All of the argregs get vpushed as a result of this.
    7554                 (when (and opt (not handled-lambda))
     7573                (when (and opt (not handled-simple-lambda))
    75557574                  (if max-args
    75567575                    (! push-max-argregs max-args)
     
    76297648                  (setq optsupvloc (- *x862-vstack* (* num-opt *x862-target-node-size*)))))))
    76307649          ;; Caller's context is saved; *x862-vstack* is valid.  Might
    7631          ;; still have method-var to worry about.
    7632           (unless handled-lambda
    7633           (when *backend-use-linear-scan*
    7634             (! reserve-spill-area))
    7635           (! save-nfp))
     7650          ;; still have method-var to worry about.
     7651          (unless handled-simple-lambda
     7652            (when *backend-use-linear-scan*
     7653              (! reserve-spill-area))
     7654            (! save-nfp))
    76367655          (unless (= 0 pregs)
    76377656            ;; Save NVRs; load constants into any that get constants.
     
    77057724                  (vinsn-list-max-spill-depth vl) nspilled)
    77067725            (unless (zerop nspilled)
    7707             ;; every var pn *x852-stack-vars* should have an lreg,
    7708             ;; and that lreg should be "pre-spilled" with a spill-offset
    7709             ;; < nspilled.  for extra credit, every potential offset < nspilled
    7710             ;; should correspond to the offset of some var.  Check these things.
    7711             (let*  ((used-offsets (make-array nspilled :element-type 'bit)))
     7726              ;; every var pn *x852-stack-vars* should have an lreg,
     7727              ;; and that lreg should be "pre-spilled" with a spill-offset
     7728              ;; < nspilled.  for extra credit, every potential offset < nspilled
     7729              ;; should correspond to the offset of some var.  Check these things.
     7730              (let*  ((used-offsets (make-array nspilled :element-type 'bit)))
    77127731                (dolist (var *x862-stack-vars*)
    77137732                  (let*  ((lreg (var-lreg var)))
     
    81058124
    81068125(defx862 x862-setq-special setq-special (seg vreg xfer sym val)
     8126  ;;(linear-scan-bailout "setq of special variable")
    81078127  (let* ((symreg ($ *x862-arg-y*))
    81088128         (valreg ($ *x862-arg-z*)))
     
    86958715
    86968716(defun x862-generate-casejump (seg vreg xfer ranges trueforms var otherwise)
    8697   (linear-scan-bailout "jumptable")
    8698   (when *x862-generate-casejump*
     8717  (when (and *x862-generate-casejump* (not *backend-use-linear-scan*))
    86998718    (with-x86-local-vinsn-macros (seg vreg xfer)
    87008719      (when ranges
     
    1090210921
    1090310922(defx862 x862-setq-free setq-free (seg vreg xfer sym val)
     10923  ;;(linear-scan-bailout "setq of free variable")
    1090410924  (let* ((rsym ($ *x862-arg-y*))
    1090510925         (rval ($ *x862-arg-z*)))
  • branches/lscan/source/compiler/nx.lisp

    r16496 r16502  
    243243         def
    244244         (let* ((*load-time-eval-token* load-time-eval-token)
    245                 (*current-function-name* (or name "an anonymous funcrion"))
     245                (*current-function-name* (or name "an anonymous function"))
    246246                (*backend-use-linear-scan*  (unless force-legacy-backend *backend-use-linear-scan*))
    247247                (*force-legacy-backend* force-legacy-backend)
  • branches/lscan/source/compiler/vinsn.lisp

    r16498 r16502  
    13841384               (child-used (member-if (lambda (pos) (> pos new-end)) (interval-use-positions parent)))
    13851385               (ncu (length child-used)))
    1386           (let* ((defs (lreg-defs lreg)))
     1386          '(let* ((defs (lreg-defs lreg)))
    13871387           (when (cdr defs)  (linear-scan-bailout (format nil "not yet - assignment/multiple definitions in spilled interval ~s" defs))))
    13881388         
     
    16791679                (insert-vinsn-before reload-vinsn ref)))))))))
    16801680
     1681 
    16811682
    16821683(defun resolve-split-intervals (seg)
     
    16851686         (nregs (length lregs)))
    16861687
    1687    
    1688                
    16891688               
    16901689    (dovector (lreg lregs )
     
    16921691             (offset (if interval (interval-spill-offset interval))))
    16931692       (when offset
     1693         (dolist (use (interval-use-positions interval))
     1694o           (unless (and (eql use (interval-begin interval))
     1695                        (null (interval-parent interval)))
     1696             (let* ((vinsn (find-vinsn seg use)))
     1697               (when (memq vinsn (lreg-defs lreg))
     1698                 (note-spill interval vinsn)))))
     1699         (do* ((child (interval-child interval) (interval-child child)))
     1700              ((null child))
     1701           (dolist (use (interval-use-positions child))
     1702             (let* ((def (find-vinsn seg use)))
     1703               (when (memq def (lreg-defs lreg))
     1704                 (note-spill child def)))))
     1705         
    16941706         (if (eql 0 (interval-flags interval))
    16951707          (do* ((child (interval-child interval) (interval-child child)))
     
    17011713              (note-reload child child-start-vinsn)
    17021714              (note-spill parent parent-end-vinsn)))
    1703            (let* ((family ()))
     1715           (let* ((family ())
     1716                  (lreg (interval-lreg interval)))
    17041717             (push interval family)
    17051718             (do* ((child (interval-child interval) (interval-child child)))
     
    17091722               (dolist (use (interval-use-positions x))
    17101723                 (let* ((v (find-vinsn seg use)))
     1724                   (when (memq v (lreg-refs lreg))
    17111725                   (note-reload x v)))))
    1712            ))))
     1726           )))))
    17131727
    17141728   
     
    17311745                          (last-use-of-interval-in-block seg interval from)
    17321746
    1733                         (or from-interval (ls-note "no frominterval for ~s" from))
    1734                         (or to-interval (break "no to interval for ~s" to))
    1735                         (when (and from-interval to-interval (not (eq from-interval to-interval)))
    1736                           (when (eql 0 (interval-flags from-interval))(note-spill from-interval from-vinsn))
    1737                      
    1738                           (note-reload to-interval to-vinsn))))))))))))))
     1747                        (when (not (eq from-interval to-interval))
     1748                          (when from-vinsn (note-spill from-interval from-vinsn))
     1749                          (when to-vinsn(note-reload to-interval to-vinsn)))))))))))))))
    17391750                             
    17401751                         
  • branches/lscan/source/lib/x8664env.lisp

    r16499 r16502  
    8282                                           (logand x8664::fp13 15)                               
    8383                                           (logand x8664::fp14 15)                               
    84                                            (logand x8664::fp15 15)))
     84))
    8585                               
    8686
Note: See TracChangeset for help on using the changeset viewer.