Changeset 7214


Ignore:
Timestamp:
Sep 14, 2007, 4:58:13 AM (12 years ago)
Author:
rme
Message:

X862-COMPILE: add some preliminary accomodations for compiling
for IA-32.

Start replacing references to x8664::arg_z, etc., with specials named
*x862-arg-z*, etc., and bound in X862-COMPILE.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/ia32/compiler/X86/x862.lisp

    r7063 r7214  
    176176(defvar *x862-result-reg* x8664::arg_z)
    177177
     178(defvar *x862-arg-z* nil)
     179(defvar *x862-arg-y* nil)
     180(defvar *x862-temp0* nil)
    178181
    179182(declaim (fixnum *x862-vstack* *x862-cstack*))
     
    296299           (x862-copy-register seg x8664::arg_z valreg)
    297300           (x862-stack-to-register seg ea x8664::arg_x)
    298            (x862-lri seg x8664::arg_y 0)
    299            (! call-subprim-3 x8664::arg_z (subprim-name->offset '.SPgvset) x8664::arg_x x8664::arg_y x8664::arg_z))
     301           (x862-lri seg *x862-arg-y* 0)
     302           (! call-subprim-3 x8664::arg_z (subprim-name->offset '.SPgvset) x8664::arg_x *x862-arg-y* x8664::arg_z))
    300303          ((memory-spec-p ea)    ; vstack slot
    301304           (x862-register-to-stack seg valreg ea))
     
    451454           (*x862-vstack* 0)
    452455           (*x862-cstack* 0)
     456           (*x862-result-reg* (target-arch-case
     457                               (:x8632 x8632::arg_z)
     458                               (:x8664 x8664::arg_z)))
     459           (*x862-arg-z* (target-arch-case (:x8632 x8632::arg_z)
     460                                           (:x8664 x8664::arg_z)))
     461           (*x862-arg-y* (target-arch-case (:x8632 x8632::arg_y)
     462                                           (:x8664 x8664::arg_y)))
     463           (*x862-temp0* (target-arch-case (:x8632 x8632::temp0)
     464                                           (:x8664 x8664::temp0)))
     465           
     466
    453467           (*x862-target-num-arg-regs* (target-arch-case
    454468                                        (:x8632 $numx8632argregs)
     
    551565                        (instruction (x86::make-x86-instruction))
    552566                        (end-code-tag (gensym))
     567                        (srt-tag (gensym))
     568                        (*x86-lap-self-reference-offsets* nil)
    553569                        debug-info)
    554570                   (make-x86-lap-label end-code-tag)
    555                    (x86-lap-directive frag-list :long `(ash (+ (- (:^ ,end-code-tag ) 8)
    556                                                              *x86-lap-entry-offset*) -3))
    557                    (x86-lap-directive frag-list :byte 0) ;regsave PC
    558                    (x86-lap-directive frag-list :byte 0) ;regsave ea
    559                    (x86-lap-directive frag-list :byte 0) ;regsave mask
    560 
     571                   ;; xxx conditionalize for 32 bit here
     572                   (target-arch-case
     573                    (:x8664
     574                     (x86-lap-directive frag-list :long `(ash (+ (- (:^ ,end-code-tag ) 8)
     575                                                                 *x86-lap-entry-offset*) -3))
     576                     (x86-lap-directive frag-list :byte 0) ;regsave PC
     577                     (x86-lap-directive frag-list :byte 0) ;regsave ea
     578                     (x86-lap-directive frag-list :byte 0)) ;regsave mask
     579                    (:x8632
     580                     (make-x86-lap-label srt-tag)
     581                     ;; room for imm word count
     582                     (x86-lap-directive frag-list :short 0)))
    561583                   (x862-expand-vinsns vinsns frag-list instruction)
    562584                   (when (or *x862-double-float-constant-alist*
     
    575597                         (let* ((val (single-float-bits sfloat)))
    576598                           (x86-lap-directive frag-list :long val)))))
    577                    (x86-lap-directive frag-list :align 3)
    578                    (x86-lap-directive frag-list :quad x8664::function-boundary-marker)
     599                   (target-arch-case
     600                    (:x8632
     601                     (x86-lap-directive frag-list :align 2)
     602                     ;; start of self reference table
     603                     (x86-lap-directive frag-list :long 0)
     604                     (emit-x86-lap-label frag-list srt-tag)
     605                     ;; make space for self-reference offsets
     606                     (do-dll-nodes (frag frag-list)
     607                       (dolist (reloc (frag-relocs frag))
     608                         (when (eq (reloc-type reloc) :self)
     609                           (x86-lap-directive frag-list :long 0))))
     610                     (x86-lap-directive frag-list :long x8632::function-boundary-marker))
     611                    (:x8664
     612                     (x86-lap-directive frag-list :align 3)
     613                     (x86-lap-directive frag-list :quad x8664::function-boundary-marker)))
     614                   
    579615                   (emit-x86-lap-label frag-list end-code-tag)
     616
    580617                   (dolist (c (reverse *x862-constant-alist*))
    581618                     (let* ((vinsn-label (cdr c)))
     
    585622                                  vinsn-label)))
    586623                       (emit-x86-lap-label frag-list vinsn-label)
    587                        (x86-lap-directive frag-list :quad 0)))
    588                  
     624                       (target-arch-case
     625                        (:x8632
     626                         (x86-lap-directive frag-list :long 0))
     627                        (:x8664
     628                         (x86-lap-directive frag-list :quad 0)))))
     629                   
    589630                   (if (logbitp $fbitnonnullenv (the fixnum (afunc-bits afunc)))
    590631                     (setq bits (+ bits (ash 1 $lfbits-nonnullenv-bit))))
     
    611652                                                           *x862-register-restore-ea*
    612653                                                           *x862-register-restore-count*))))
    613                      (when debug-info
    614                        (x86-lap-directive frag-list :quad 0))
    615                      (when fname
    616                        (x86-lap-directive frag-list :quad 0))
    617                      (x86-lap-directive frag-list :quad 0)
    618                      (relax-frag-list frag-list)
     654                     (target-arch-case
     655                      (:x8632
     656                       (when debug-info
     657                         (x86-lap-directive frag-list :long 0))
     658                       (when fname
     659                         (x86-lap-directive frag-list :long 0))
     660                       (x86-lap-directive frag-list :long 0))
     661                      (:x8664
     662                       (when debug-info
     663                         (x86-lap-directive frag-list :quad 0))
     664                       (when fname
     665                         (x86-lap-directive frag-list :quad 0))
     666                       (x86-lap-directive frag-list :quad 0)))
     667                     
     668                     (relax-frag-list frag-list)
    619669                     (apply-relocs frag-list)
    620670                     (fill-for-alignment frag-list)
    621                      (x862-lap-process-regsave-info frag-list regsave-label regsave-mask regsave-addr)
    622                      (setf (afunc-lfun afunc)
    623                            #+x86-target
    624                            (if (eq *host-backend* *target-backend*)
    625                              (create-x86-function fname frag-list *x862-constant-alist* bits debug-info)
    626                              (cross-create-x86-function fname frag-list *x862-constant-alist* bits debug-info))
    627                            #-x86-target
    628                            (cross-create-x86-function fname frag-list *x862-constant-alist* bits debug-info)))
     671                     (target-arch-case
     672                      (:x8632
     673                       (let* ((label (find srt-tag *x86-lap-labels* :test #'eq :key #'x86-lap-label-name))
     674                              (start-frag (dll-header-first frag-list))
     675                              (nbytes (frag-list-length frag-list))
     676                              (nwords (ash nbytes (- x8632::word-shift)))
     677                              (srt-frag (x86-lap-label-frag label))
     678                              (srt-index (x86-lap-label-offset label)))
     679                         ;; fill in self-reference offsets
     680                         (do-dll-nodes (frag frag-list)
     681                           (dolist (reloc (frag-relocs frag))
     682                             (when (eq (reloc-type reloc) :self)
     683                               (setf (frag-ref-32 srt-frag srt-index)
     684                                     (+ (frag-address frag) (reloc-pos reloc)))
     685                               (incf srt-index 4))))
     686                         ;; count of 32-bit immediate elements
     687                         (setf (frag-ref start-frag 0) (logand #xff nwords)
     688                               (frag-ref start-frag 1) (logand #xff00 nwords)))
     689                       (show-frag-bytes frag-list)))
     690
     691                     (x862-lap-process-regsave-info frag-list regsave-label regsave-mask regsave-addr)
     692                     (setf (afunc-lfun afunc)
     693                           #+x86-target
     694                           (if (eq *host-backend* *target-backend*)
     695                             (create-x86-function fname frag-list *x862-constant-alist* bits debug-info)
     696                             (cross-create-x86-function fname frag-list *x862-constant-alist* bits debug-info))
     697                           #-x86-target
     698                           (cross-create-x86-function fname frag-list *x862-constant-alist* bits debug-info)))
    629699                   (x862-digest-symbols))))
    630700          (backend-remove-labels))))
     
    681751                      (error "Missing or bad ~s label: ~s"
    682752                             (if start-p 'start 'end) sym)))
    683                   x8664::fulltag-function)))
     753                  (target-arch-case
     754                   (:x8632 x8632::fulltag-misc) ;xxx
     755                   (:x8664 x8664::fulltag-function)))))
    684756          (destructuring-bind (var sym startlab endlab) info
    685757            (let* ((ea (var-ea var))
     
    894966        (if (setq reg (x862-assign-register-var rest))
    895967          (progn
    896             (x862-copy-register seg reg x8664::arg_z)
     968            (x862-copy-register seg reg *x862-arg-z*)
    897969            (x862-set-var-ea seg rest reg))
    898970            (let* ((loc *x862-vstack*))
    899               (x862-vpush-register seg x8664::arg_z :reserved)
     971              (x862-vpush-register seg *x862-arg-z* :reserved)
    900972              (x862-note-top-cell rest)
    901973              (x862-bind-var seg rest loc *x862-top-vstack-lcell*))))
     
    922994            (if reg
    923995              (x862-form seg reg regloadedlabel initform)
    924               (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ x8664::arg_z)) (x862-vloc-ea vloc)))
     996              (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ *x862-arg-z*)) (x862-vloc-ea vloc)))
    925997            (@ skipinitlabel)))
    926998        (if reg
     
    9531025            (if reg
    9541026              (x862-form seg reg regloadedlabel initform)
    955               (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ x8664::arg_z)) (x862-vloc-ea vloc)))
     1027              (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ *x862-arg-z*)) (x862-vloc-ea vloc)))
    9561028            (@ skipinitlabel)))
    9571029        (if reg
     
    10001072          (dotimes (i nstackargs)
    10011073            (x862-new-vstack-lcell :reserved *x862-target-lcell-size* 0 nil))
    1002           (if (>= nargs 3)
    1003             (push (x862-vpush-arg-register seg ($ x8664::arg_x) xvar) reg-vars))
    1004           (if (>= nargs 2)
    1005             (push (x862-vpush-arg-register seg ($ x8664::arg_y) yvar) reg-vars))
    1006           (if (>= nargs 1)
    1007             (push (x862-vpush-arg-register seg ($ x8664::arg_z) zvar) reg-vars))))
     1074          (target-arch-case
     1075           (:x8632
     1076            (if (>= nargs 2)
     1077              (push (x862-vpush-arg-register seg ($ x8632::arg_y) yvar) reg-vars))
     1078            (if (>= nargs 1)
     1079              (push (x862-vpush-arg-register seg ($ x8632::arg_z) zvar) reg-vars)))
     1080           (:x8664
     1081            (if (>= nargs 3)
     1082              (push (x862-vpush-arg-register seg ($ x8664::arg_x) xvar) reg-vars))
     1083            (if (>= nargs 2)
     1084              (push (x862-vpush-arg-register seg ($ x8664::arg_y) yvar) reg-vars))
     1085            (if (>= nargs 1)
     1086              (push (x862-vpush-arg-register seg ($ x8664::arg_z) zvar) reg-vars))))))
    10081087      reg-vars)))
    10091088
     
    10701149            (with-crf-target () crf
    10711150              (x862-compare-ea-to-nil seg crf (x862-make-compound-cd 0 skipinitlabel) (x862-vloc-ea spvloc) x86::x86-e-bits t))
    1072             (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ x8664::arg_z)) (x862-vloc-ea vloc))
     1151            (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ *x862-arg-z*)) (x862-vloc-ea vloc))
    10731152            (@ skipinitlabel)))
    10741153        (x862-bind-structured-var seg var vloc var-lcell context)
     
    10871166             (sploc (%i+ vloc *x862-target-node-size*))
    10881167             (var-lcell (pop lcells))
    1089              (sp-reg ($ x8664::arg_z))
     1168             (sp-reg ($ *x862-arg-z*))
    10901169             (sp-lcell (pop lcells)))
    10911170        (unless (nx-null initform)
     
    10941173            (with-crf-target () crf
    10951174              (x862-compare-register-to-nil seg crf (x862-make-compound-cd 0 skipinitlabel) sp-reg x86::x86-e-bits t))
    1096             (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ x8664::arg_z)) (x862-vloc-ea vloc))
     1175            (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ *x862-arg-z*)) (x862-vloc-ea vloc))
    10971176            (@ skipinitlabel)))
    10981177        (x862-bind-structured-var seg var vloc var-lcell context)
     
    12261305(defun x862-mvpass (seg form &optional xfer)
    12271306  (with-x86-local-vinsn-macros (seg)
    1228     (x862-form seg  ($ x8664::arg_z) (logior (or xfer 0) $backend-mvpass-mask) form)))
     1307    (x862-form seg  ($ *x862-arg-z*) (logior (or xfer 0) $backend-mvpass-mask) form)))
    12291308
    12301309(defun x862-adjust-vstack (delta)
     
    13971476         (:x8664 t))
    13981477      (! box-fixnum node-dest s32-src)
    1399       (let* ((arg_z ($ x8664::arg_z))
     1478      (let* ((arg_z ($ *x862-arg-z*))
    14001479             (imm0 ($ x8664::imm0 :mode :s32)))
    14011480        (x862-copy-register seg imm0 s32-src)
     
    14261505         (:x8664 t))
    14271506      (! box-fixnum node-dest u32-src)
    1428       (let* ((arg_z ($ x8664::arg_z))
     1507      (let* ((arg_z ($ *x862-arg-z*))
    14291508             (imm0 ($ x8664::imm0 :mode :u32)))
    14301509        (x862-copy-register seg imm0 u32-src)
     
    14441523        (! set-bigits-after-fixnum-overflow node-dest)
    14451524        (@ no-overflow))
    1446       (let* ((arg_z ($ x8664::arg_z))
     1525      (let* ((arg_z ($ *x862-arg-z*))
    14471526             (imm0 ($ x8664::imm0 :mode :u64)))
    14481527        (x862-copy-register seg imm0 u64-src)
     
    16411720        (if (or safe (not index-known-fixnum))
    16421721          (multiple-value-setq (src unscaled-idx)
    1643             (x862-two-untargeted-reg-forms seg vector x8664::arg_y index x8664::arg_z))
    1644           (setq src (x862-one-untargeted-reg-form seg vector x8664::arg_z)))
     1722            (x862-two-untargeted-reg-forms seg vector *x862-arg-y* index *x862-arg-z*))
     1723          (setq src (x862-one-untargeted-reg-form seg vector *x862-arg-z*)))
    16451724        (when safe
    16461725          (if (typep safe 'fixnum)
     
    16821761                                              array ($ x8664::temp0)
    16831762                                              i ($ x8664::arg_x)
    1684                                               j ($ x8664::arg_y)
     1763                                              j ($ *x862-arg-y*)
    16851764                                              new val-reg)
    1686                 (values ($ x8664::temp0) ($ x8664::arg_x) ($ x8664::arg_y) ($ x8664::arg_z)))
     1765                (values ($ x8664::temp0) ($ x8664::arg_x) ($ *x862-arg-y*) ($ *x862-arg-z*)))
    16871766              (x862-four-untargeted-reg-forms seg
    16881767                                              array ($ x8664::temp0)
    16891768                                              i ($ x8664::arg_x)
    1690                                               j ($ x8664::arg_y)
     1769                                              j ($ *x862-arg-y*)
    16911770                                              new val-reg))))
    16921771        (let* ((*available-backend-imm-temps* *available-backend-imm-temps*))
     
    17071786              (! trap-unless-fixnum unscaled-j)))
    17081787          (with-imm-target () dim1
    1709             (let* ((idx-reg ($ x8664::arg_y)))
     1788            (let* ((idx-reg ($ *x862-arg-y*)))
    17101789              (if constidx
    17111790                (if needs-memoization
    1712                   (x862-lri seg x8664::arg_y (ash constidx *x862-target-fixnum-shift*)))
     1791                  (x862-lri seg *x862-arg-y* (ash constidx *x862-target-fixnum-shift*)))
    17131792                (progn
    17141793                  (if safe                 
     
    17541833                  unscaled-i ($ x8664::temp0)
    17551834                  unscaled-j ($ x8664::arg_x)
    1756                   unscaled-k ($ x8664::arg_y))
     1835                  unscaled-k ($ *x862-arg-y*))
    17571836            (x862-push-register
    17581837             seg
    1759              (x862-one-untargeted-reg-form seg array ($ x8664::arg_z)))
     1838             (x862-one-untargeted-reg-form seg array ($ *x862-arg-z*)))
    17601839            (x862-four-targeted-reg-forms seg
    17611840                                          i ($ x8664::temp0)
    17621841                                          j ($ x8664::arg_x)
    1763                                           k ($ x8664::arg_y)
     1842                                          k ($ *x862-arg-y*)
    17641843                                          new val-reg)
    17651844            (x862-pop-register seg src)))
     
    17851864          (with-imm-target () dim1
    17861865            (with-imm-target (dim1) dim2
    1787               (let* ((idx-reg ($ x8664::arg_y)))
     1866              (let* ((idx-reg ($ *x862-arg-y*)))
    17881867                (if constidx
    17891868                  (when needs-memoization
     
    18141893                 (+ (* i-known-fixnum dim1) j-known-fixnum))))
    18151894      (if constidx
    1816         (setq src (x862-one-targeted-reg-form seg array ($ x8664::arg_z)))
     1895        (setq src (x862-one-targeted-reg-form seg array ($ *x862-arg-z*)))
    18171896        (multiple-value-setq (src unscaled-i unscaled-j)
    18181897          (x862-three-untargeted-reg-forms seg
    18191898                                           array x8664::arg_x
    1820                                            i x8664::arg_y
    1821                                            j x8664::arg_z)))
     1899                                           i *x862-arg-y*
     1900                                           j *x862-arg-z*)))
    18221901      (when safe       
    18231902        (when (typep safe 'fixnum)
     
    18631942                    k-known-fixnum))))
    18641943      (if constidx
    1865         (setq src (x862-one-targeted-reg-form seg array ($ x8664::arg_z)))
     1944        (setq src (x862-one-targeted-reg-form seg array ($ *x862-arg-z*)))
    18661945        (multiple-value-setq (src unscaled-i unscaled-j unscaled-k)
    18671946          (x862-four-untargeted-reg-forms seg
    18681947                                           array x8664::temp0
    18691948                                           i x8664::arg_x
    1870                                            j x8664::arg_y
    1871                                            k x8664::arg_z)))
     1949                                           j *x862-arg-y*
     1950                                           k *x862-arg-z*)))
    18721951      (when safe       
    18731952        (when (typep safe 'fixnum)
     
    19061985        (if (or safe (not index-known-fixnum))
    19071986          (multiple-value-setq (src unscaled-idx target)
    1908             (x862-three-untargeted-reg-forms seg vector x8664::arg_y index x8664::arg_z value (or vreg target)))
     1987            (x862-three-untargeted-reg-forms seg vector *x862-arg-y* index *x862-arg-z* value (or vreg target)))
    19091988          (multiple-value-setq (src target)
    1910             (x862-two-untargeted-reg-forms seg vector x8664::arg_y value (or vreg target))))
     1989            (x862-two-untargeted-reg-forms seg vector *x862-arg-y* value (or vreg target))))
    19111990        (when safe
    19121991          (with-imm-temps (target) ()   ; Don't use target in type/bounds check
     
    19822061         (next-imm-target (available-imm-temp  *available-backend-imm-temps*))
    19832062         (next-fp-target (available-fp-temp *available-backend-fp-temps*))
    1984          (acc (make-wired-lreg x8664::arg_z)))
     2063         (acc (make-wired-lreg *x862-arg-z*)))
    19852064    (cond ((or is-node
    19862065               (eq vreg :push)
     
    21832262      (cond ((and is-node node-value-needs-memoization)
    21842263             (unless (and (eql (hard-regspec-value src) x8664::arg_x)
    2185                           (eql (hard-regspec-value unscaled-idx) x8664::arg_y)
    2186                           (eql (hard-regspec-value val-reg) x8664::arg_z))
     2264                          (eql (hard-regspec-value unscaled-idx) *x862-arg-y*)
     2265                          (eql (hard-regspec-value val-reg) *x862-arg-z*))
    21872266               (nx-error "Bug: invalid register targeting for gvset: ~s" (list src unscaled-idx val-reg)))
    21882267             (! call-subprim-3 val-reg (subprim-name->offset '.SPgvset) src unscaled-idx val-reg))
     
    23052384           (index-known-fixnum (acode-fixnum-form-p index)))
    23062385      (let* ((src ($ x8664::arg_x))
    2307              (unscaled-idx ($ x8664::arg_y))
    2308              (result-reg ($ x8664::arg_z)))
     2386             (unscaled-idx ($ *x862-arg-y*))
     2387             (result-reg ($ *x862-arg-z*)))
    23092388        (cond (needs-memoization
    23102389               (x862-three-targeted-reg-forms seg
     
    24372516                                  (backend-get-next-label))))
    24382517          (unless simple-case
    2439             (x862-vpush-register seg (x862-one-untargeted-reg-form seg fn x8664::arg_z))
     2518            (x862-vpush-register seg (x862-one-untargeted-reg-form seg fn *x862-arg-z*))
    24402519            (setq fn (x862-vloc-ea vstack)))
    24412520          (x862-invoke-fn seg fn (x862-arglist seg arglist mv-return-label) spread-p xfer mv-return-label)
     
    24532532          (setq *x862-cstack* cstack)
    24542533          (when (or (logbitp $backend-mvpass-bit xfer) (not mv-p))
    2455             (<- x8664::arg_z)
     2534            (<- *x862-arg-z*)
    24562535            (x862-branch seg (logand (lognot $backend-mvpass-mask) xfer)))))
    24572536      nil)))
     
    24722551    (if jump-p
    24732552      (! jump-known-symbol)
    2474       (! call-known-symbol x8664::arg_z))))
     2553      (! call-known-symbol *x862-arg-z*))))
    24752554
    24762555;;; Nargs = nil -> multiple-value case.
     
    26412720      (let* ((inherited-vars (afunc-inherited-vars afunc))
    26422721             (arch (backend-target-arch *target-backend*))
    2643              (dest ($ x8664::arg_z))
     2722             (dest ($ *x862-arg-z*))
    26442723             (vsize (+ (length inherited-vars)
    26452724                       5                ; %closure-code%, afunc
     
    26612740              (x862-lri seg x8664::imm1 (- (ash (logandc2 (+ vsize 2) 1) (arch::target-word-shift arch)) (target-arch-case  (:x8664 x8664::fulltag-misc))))
    26622741              (! %allocate-uvector dest)))
    2663           (! init-nclosure x8664::arg_z)
     2742          (! init-nclosure *x862-arg-z*)
    26642743          (x862-store-immediate seg (x862-afunc-lfun-ref afunc) x8664::ra0)
    2665           (with-node-temps (x8664::arg_z) (t0 t1 t2 t3)
     2744          (with-node-temps (*x862-arg-z*) (t0 t1 t2 t3)
    26662745            (do* ((func x8664::ra0 nil))
    26672746                 ((null inherited-vars))
     
    26712750                     (t3r (if inherited-vars (var-to-reg (pop inherited-vars) t3))))
    26722751                (setq cell (set-some-cells dest cell t0r t1r t2r t3r)))))
    2673           (x862-lri seg x8664::arg_y (ash (logior (ash 1 $lfbits-noname-bit) (ash 1 $lfbits-trampoline-bit)) *x862-target-fixnum-shift*))
    2674           (! misc-set-c-node x8664::arg_y dest cell))
     2752          (x862-lri seg *x862-arg-y* (ash (logior (ash 1 $lfbits-noname-bit) (ash 1 $lfbits-trampoline-bit)) *x862-target-fixnum-shift*))
     2753          (! misc-set-c-node *x862-arg-y* dest cell))
    26752754        (! finalize-closure dest)
    26762755        dest))))
     
    27512830              (x862-adjust-vstack *x862-target-node-size*))
    27522831             
    2753             (let* ((reg (x862-one-untargeted-reg-form seg arg x8664::arg_z)))
     2832            (let* ((reg (x862-one-untargeted-reg-form seg arg *x862-arg-z*)))
    27542833              (x862-vpush-register-arg seg reg)))
    27552834          (incf n)))
     
    27592838               (xform (%caddr revregargs)))
    27602839          (if (eq 3 nregs)
    2761             (x862-three-targeted-reg-forms seg xform ($ x8664::arg_x) yform ($ x8664::arg_y) zform ($ x8664::arg_z))
     2840            (x862-three-targeted-reg-forms seg xform ($ x8664::arg_x) yform ($ *x862-arg-y*) zform ($ *x862-arg-z*))
    27622841            (if (eq 2 nregs)
    2763               (x862-two-targeted-reg-forms seg yform ($ x8664::arg_y) zform ($ x8664::arg_z))
    2764               (x862-one-targeted-reg-form seg zform ($ x8664::arg_z))))))
     2842              (x862-two-targeted-reg-forms seg yform ($ *x862-arg-y*) zform ($ *x862-arg-z*))
     2843              (x862-one-targeted-reg-form seg zform ($ *x862-arg-z*))))))
    27652844      n)))
    27662845
     
    28972976            ((= class hard-reg-class-gpr)
    28982977             (if (= mode hard-reg-class-gpr-mode-node)
    2899                ($ x8664::arg_z)
     2978               ($ *x862-arg-z*)
    29002979               (make-wired-lreg x8664::imm0 :mode mode)))
    29012980            (t (error "Unknown register class for reg ~s" reg))))))
     
    32653344      (if (and (eql u8-operator (%nx1-operator lisptag))
    32663345               (eql 0 u8constant))
    3267         (let* ((formreg (x862-one-untargeted-reg-form seg form x8664::arg_z)))
     3346        (let* ((formreg (x862-one-untargeted-reg-form seg form *x862-arg-z*)))
    32683347         
    32693348          (! set-flags-from-lisptag formreg))
     
    33033382          (x862-compare-u8 seg vreg xfer u8-operand u8 (if (and iu8 (not (eq cr-bit x86::x86-e-bits))) (logxor 1 cr-bit) cr-bit) true-p u8-operator)
    33043383          (if (and boolean (or js32 is32))
    3305             (let* ((reg (x862-one-untargeted-reg-form seg (if js32 i j) x8664::arg_z))
     3384            (let* ((reg (x862-one-untargeted-reg-form seg (if js32 i j) *x862-arg-z*))
    33063385                   (constant (or js32 is32)))
    33073386              (if (zerop constant)
     
    33203399                seg
    33213400                (if js32 i j)
    3322                 x8664::arg_z)
     3401                *x862-arg-z*)
    33233402               cr-bit
    33243403               true-p
    33253404               (or js32 is32))
    3326               (multiple-value-bind (ireg jreg) (x862-two-untargeted-reg-forms seg i x8664::arg_y j x8664::arg_z)
     3405              (multiple-value-bind (ireg jreg) (x862-two-untargeted-reg-forms seg i *x862-arg-y* j *x862-arg-z*)
    33273406                (x862-compare-registers seg vreg xfer ireg jreg cr-bit true-p)))))))))
    33283407
     
    34843563
    34853564(defun x862-test-%izerop (seg vreg xfer form cr-bit true-p)
    3486   (x862-test-reg-%izerop seg vreg xfer (x862-one-untargeted-reg-form seg form x8664::arg_z) cr-bit true-p 0))
     3565  (x862-test-reg-%izerop seg vreg xfer (x862-one-untargeted-reg-form seg form *x862-arg-z*) cr-bit true-p 0))
    34873566
    34883567(defun x862-test-reg-%izerop (seg vreg xfer reg cr-bit true-p  zero)
     
    37853864                 (x862-open-undo $undostkblk curstack)
    37863865                 (! stack-cons-list))
    3787                (setq val x8664::arg_z))
     3866               (setq val *x862-arg-z*))
    37883867              ((eq op (%nx1-operator list*))
    37893868               (let* ((arglist (%cadr val)))                   
     
    37953874                   (! stack-cons-list*)
    37963875                   (x862-open-undo $undostkblk curstack))
    3797                  (setq val x8664::arg_z)))
     3876                 (setq val *x862-arg-z*)))
    37983877              ((eq op (%nx1-operator multiple-value-list))
    37993878               (x862-multiple-value-body seg (%cadr val))
    38003879               (x862-open-undo $undostkblk curstack)
    38013880               (! stack-cons-list)
    3802                (setq val x8664::arg_z))
     3881               (setq val *x862-arg-z*))
    38033882              ((eq op (%nx1-operator cons))
    3804                (let* ((y ($ x8664::arg_y))
    3805                       (z ($ x8664::arg_z))
    3806                       (result ($ x8664::arg_z)))
     3883               (let* ((y ($ *x862-arg-y*))
     3884                      (z ($ *x862-arg-z*))
     3885                      (result ($ *x862-arg-z*)))
    38073886                 (x862-two-targeted-reg-forms seg (%cadr val) y (%caddr val) z)
    38083887                 (x862-open-undo $undostkblk )
     
    38203899                 (if (nx-constant-form-p clear-form)
    38213900                   (progn
    3822                      (x862-one-targeted-reg-form seg (%cadr val) ($ x8664::arg_z))
     3901                     (x862-one-targeted-reg-form seg (%cadr val) ($ *x862-arg-z*))
    38233902                     (if (nx-null clear-form)
    38243903                       (! make-stack-block)
     
    38273906                                    (let ((stack-block-0-label (backend-get-next-label))
    38283907                                          (done-label (backend-get-next-label))
    3829                                           (rval ($ x8664::arg_z))
    3830                                           (rclear ($ x8664::arg_y)))
     3908                                          (rval ($ *x862-arg-z*))
     3909                                          (rclear ($ *x862-arg-y*)))
    38313910                                      (x862-two-targeted-reg-forms seg (%cadr val) rval clear-form rclear)
    38323911                                      (! compare-to-nil crf rclear)
     
    38383917                                      (@ done-label)))))
    38393918               (x862-open-undo $undo-x86-c-frame)
    3840                (setq val ($ x8664::arg_z)))
     3919               (setq val ($ *x862-arg-z*)))
    38413920              ((eq op (%nx1-operator make-list))
    3842                (x862-two-targeted-reg-forms seg (%cadr val) ($ x8664::arg_y) (%caddr val) ($ x8664::arg_z))
     3921               (x862-two-targeted-reg-forms seg (%cadr val) ($ *x862-arg-y*) (%caddr val) ($ *x862-arg-z*))
    38433922               (x862-open-undo $undostkblk curstack)
    38443923               (! make-stack-list)
    3845                (setq val x8664::arg_z))       
     3924               (setq val *x862-arg-z*))       
    38463925              ((eq (%car val) (%nx1-operator vector))
    38473926               (let* ((*x862-vstack* *x862-vstack*)
     
    38503929                 (! make-stack-vector))
    38513930               (x862-open-undo $undostkblk)
    3852                (setq val x8664::arg_z))
     3931               (setq val *x862-arg-z*))
    38533932              ((eq op (%nx1-operator %gvector))
    38543933               (let* ((*x862-vstack* *x862-vstack*)
     
    38583937                 (! make-stack-gvector))
    38593938               (x862-open-undo $undostkblk)
    3860                (setq val x8664::arg_z))
     3939               (setq val *x862-arg-z*))
    38613940              ((eq op (%nx1-operator closed-function))
    38623941               (setq val (x862-make-closure seg (cadr val) t))) ; can't error
     
    38693948                     (if init-p
    38703949                       (progn
    3871                          (x862-three-targeted-reg-forms seg element-count ($ x8664::arg_x) subtag ($ x8664::arg_y) init ($ x8664::arg_z))
     3950                         (x862-three-targeted-reg-forms seg element-count ($ x8664::arg_x) subtag ($ *x862-arg-y*) init ($ *x862-arg-z*))
    38723951                         (! stack-misc-alloc-init))
    38733952                       (progn
    3874                          (x862-two-targeted-reg-forms seg element-count ($ x8664::arg_y)  subtag ($ x8664::arg_z))
     3953                         (x862-two-targeted-reg-forms seg element-count ($ *x862-arg-y*)  subtag ($ *x862-arg-z*))
    38753954                         (! stack-misc-alloc)))
    38763955                     (if is-node
    38773956                       (x862-open-undo $undostkblk)
    38783957                       (x862-open-undo $undo-x86-c-frame))
    3879                      (setq val ($ x8664::arg_z))))))))))
     3958                     (setq val ($ *x862-arg-z*))))))))))
    38803959  val)
    38813960
     
    39344013                            (x862-new-vstack-lcell :node *x862-target-lcell-size* bits var)
    39354014                            (x862-adjust-vstack *x862-target-node-size*))
    3936                           (x862-vpush-register seg (x862-one-untargeted-reg-form seg val x8664::arg_z) :node var bits)))))
     4015                          (x862-vpush-register seg (x862-one-untargeted-reg-form seg val *x862-arg-z*) :node var bits)))))
    39374016                  (x862-set-var-ea seg var (or reg (x862-vloc-ea vloc closed-p)))
    39384017                  (if reg
     
    40374116                     (t
    40384117                      (if ea-p
    4039                         (x862-store-ea seg value x8664::arg_z)
    4040                         (x862-one-targeted-reg-form seg value ($ x8664::arg_z)))
     4118                        (x862-store-ea seg value *x862-arg-z*)
     4119                        (x862-one-targeted-reg-form seg value ($ *x862-arg-z*)))
    40414120                      (! bind-interrupt-level))))
    40424121             (x862-open-undo $undointerruptlevel))
     
    40444123             (if (or nil-p self-p)
    40454124               (progn
    4046                  (x862-store-immediate seg (x862-symbol-value-cell sym) x8664::arg_z)
     4125                 (x862-store-immediate seg (x862-symbol-value-cell sym) *x862-arg-z*)
    40474126                 (if nil-p
    40484127                   (! bind-nil)
     
    40524131               (progn
    40534132                 (if ea-p
    4054                    (x862-store-ea seg value x8664::arg_z)
    4055                    (x862-one-targeted-reg-form seg value ($ x8664::arg_z)))
    4056                  (x862-store-immediate seg (x862-symbol-value-cell sym) ($ x8664::arg_y))
     4133                   (x862-store-ea seg value *x862-arg-z*)
     4134                   (x862-one-targeted-reg-form seg value ($ *x862-arg-z*)))
     4135                 (x862-store-immediate seg (x862-symbol-value-cell sym) ($ *x862-arg-y*))
    40574136                 (! bind)))
    40584137             (x862-open-undo $undospecial)))
     
    41124191               (if for-value
    41134192                 (progn
    4114                    (x862-one-targeted-reg-form seg val ($ x8664::arg_z))
     4193                   (x862-one-targeted-reg-form seg val ($ *x862-arg-z*))
    41154194                   (progn
    41164195                       (if intval
    41174196                         (x862-lri seg x8664::imm0 intval)
    4118                          (! deref-macptr x8664::imm0 x8664::arg_z))
    4119                        (values x8664::imm0 x8664::arg_z)))
     4197                         (! deref-macptr x8664::imm0 *x862-arg-z*))
     4198                       (values x8664::imm0 *x862-arg-z*)))
    41204199                 (values (x862-macptr-arg-to-reg seg val ($ x8664::imm0 :mode :address)) nil))))
    41214200        (unless (typep offval '(signed-byte 32))
     
    41334212                      (with-imm-target () (ptr-reg :address)
    41344213                        (with-imm-target (ptr-reg) (offsetreg :signed-natural)
    4135                           (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ x8664::arg_z))
    4136                           (! fixnum->signed-natural offsetreg x8664::arg_z)
     4214                          (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ *x862-arg-z*))
     4215                          (! fixnum->signed-natural offsetreg *x862-arg-z*)
    41374216                          (! mem-set-constant-doubleword intval ptr-reg offsetreg)))))
    41384217               (if for-value
     
    41554234               (with-imm-target () (ptr-reg :address)
    41564235                 (with-imm-target (ptr-reg) (offset-reg :address)
    4157                    (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ x8664::arg_z))
    4158                    (! fixnum->signed-natural offset-reg x8664::arg_z)
     4236                   (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ *x862-arg-z*))
     4237                   (! fixnum->signed-natural offset-reg *x862-arg-z*)
    41594238                   (! fixnum-add2 ptr-reg offset-reg)
    41604239                   (x862-push-register seg ptr-reg)))
     
    41894268        (declare (fixnum size))
    41904269        (flet ((val-to-argz-and-imm0 ()
    4191                  (x862-one-targeted-reg-form seg val ($ x8664::arg_z))
     4270                 (x862-one-targeted-reg-form seg val ($ *x862-arg-z*))
    41924271                 (if (eq size 8)
    41934272                   (if signed
    41944273                     (! gets64)
    41954274                     (! getu64))
    4196                    (! fixnum->signed-natural x8664::imm0 x8664::arg_z))))
     4275                   (! fixnum->signed-natural x8664::imm0 *x862-arg-z*))))
    41974276
    41984277          (and offval (%i> (integer-length offval) 31) (setq offval nil))
     
    42184297                        (with-imm-target () (ptr-reg :address)
    42194298                          (with-imm-target (ptr-reg) (offsetreg :signed-natural)
    4220                             (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ x8664::arg_z))
    4221                             (! fixnum->signed-natural offsetreg x8664::arg_z)
     4299                            (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ *x862-arg-z*))
     4300                            (! fixnum->signed-natural offsetreg *x862-arg-z*)
    42224301                            (case size
    42234302                              (8 (! mem-set-constant-doubleword intval ptr-reg offsetreg))
     
    42424321                     (1 (! mem-set-c-byte x8664::imm0 ptr-reg offval))))
    42434322                 (if for-value
    4244                    (<- x8664::arg_z)))
     4323                   (<- *x862-arg-z*)))
    42454324                (t
    42464325                 (with-imm-target () (ptr-reg :address)
    42474326                   (with-imm-target (ptr-reg) (offset-reg :address)
    4248                      (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ x8664::arg_z))
    4249                      (! fixnum->signed-natural offset-reg x8664::arg_z)
     4327                     (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ *x862-arg-z*))
     4328                     (! fixnum->signed-natural offset-reg *x862-arg-z*)
    42504329                     (! fixnum-add2 ptr-reg offset-reg)
    42514330                     (x862-push-register seg ptr-reg)))
     
    42594338                     (1 (! mem-set-c-byte x8664::imm0 ptr-reg 0))))
    42604339                 (if for-value
    4261                    (< x8664::arg_z))))
     4340                   (< *x862-arg-z*))))
    42624341
    42634342          (^))))))
     
    43604439                  (! ref-symbol-value-inline target src)
    43614440                  (! %ref-symbol-value-inline target src))))
    4362             (let* ((src ($ x8664::arg_z))
    4363                    (dest ($ x8664::arg_z)))
     4441            (let* ((src ($ *x862-arg-z*))
     4442                   (dest ($ *x862-arg-z*)))
    43644443              (x862-store-immediate seg (x862-symbol-value-cell sym) src)
    43654444              (if check-boundp
     
    43724451(defun x862-extract-charcode (seg vreg xfer char safe)
    43734452  (with-x86-local-vinsn-macros (seg vreg xfer)
    4374     (let* ((src (x862-one-untargeted-reg-form seg char x8664::arg_z)))
     4453    (let* ((src (x862-one-untargeted-reg-form seg char *x862-arg-z*)))
    43754454      (when safe
    43764455        (! trap-unless-character src))
     
    43854464    (setq safe nil))                    ; May also have been passed as NIL.
    43864465  (with-x86-local-vinsn-macros (seg vreg xfer)
    4387     (let* ((src (x862-one-untargeted-reg-form seg listform x8664::arg_z)))
     4466    (let* ((src (x862-one-untargeted-reg-form seg listform *x862-arg-z*)))
    43884467      (when safe
    43894468        (! trap-unless-list src))
     
    44514530                     (progn
    44524531                       (push nil pending)
    4453                        (x862-vpush-register seg (x862-one-untargeted-reg-form seg form x8664::arg_z)))))
     4532                       (x862-vpush-register seg (x862-one-untargeted-reg-form seg form *x862-arg-z*)))))
    44544533                 (x862-lri seg x8664::imm0 header)
    44554534                 (x862-lri seg x8664::imm1 (- (ash (logandc2 (+ n 2) 1) (arch::target-word-shift arch)) (target-arch-case  (:x8664 x8664::fulltag-misc))))
     
    44924571    (setq safe nil))                    ; May also have been passed as NIL.
    44934572  (with-x86-local-vinsn-macros (seg vreg xfer)
    4494     (multiple-value-bind (ptr-vreg val-vreg) (x862-two-targeted-reg-forms seg ptrform ($ x8664::arg_y) valform ($ x8664::arg_z))
     4573    (multiple-value-bind (ptr-vreg val-vreg) (x862-two-targeted-reg-forms seg ptrform ($ *x862-arg-y*) valform ($ *x862-arg-z*))
    44954574      (when safe
    44964575        (! trap-unless-cons ptr-vreg))
    44974576      (if setcdr
    4498         (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPrplacd) ptr-vreg val-vreg)
    4499         (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPrplaca) ptr-vreg val-vreg))
     4577        (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPrplacd) ptr-vreg val-vreg)
     4578        (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPrplaca) ptr-vreg val-vreg))
    45004579      (if returnptr
    45014580        (<- ptr-vreg)
     
    45724651        (setq xfer (logand (lognot $backend-mvpass-mask) xfer))
    45734652        (unless *x862-returning-values*
    4574           (x862-vpush-register seg x8664::arg_z)
     4653          (x862-vpush-register seg *x862-arg-z*)
    45754654          (x862-set-nargs seg 1)))
    45764655      (if (neq 0 xfer)
     
    46894768              ;; case of a null vd can certainly avoid it; the check
    46904769              ;; of numundo is to keep $acc boxed in case of nthrow.
    4691               (x862-form  seg (if (or vreg (not (%izerop numundo))) x8664::arg_z) nil body)
     4770              (x862-form  seg (if (or vreg (not (%izerop numundo))) *x862-arg-z*) nil body)
    46924771              (x862-unwind-set seg xfer old-stack)
    4693               (when vreg (<- x8664::arg_z))
     4772              (when vreg (<- *x862-arg-z*))
    46944773              (^))))))))
    46954774
     
    47744853            (when label
    47754854              (! start-mv-call (aref *backend-labels* label)))
    4776             (x862-temp-push-node seg (x862-one-untargeted-reg-form seg fn x8664::arg_z))
     4855            (x862-temp-push-node seg (x862-one-untargeted-reg-form seg fn *x862-arg-z*))
    47774856            (x862-multiple-value-body seg (pop arglist))
    47784857            (x862-open-undo $undostkblk)
     
    47914870                (^)))
    47924871            (progn
    4793               (<- x8664::arg_z)
     4872              (<- *x862-arg-z*)
    47944873              (^))))))))
    47954874
     
    50115090                (setq n 0))
    50125091              (if *x862-open-code-inline*
    5013                 (let* ((*available-backend-node-temps* (bitclr x8664::arg_z (bitclr x8664::rcx *available-backend-node-temps*))))
     5092                (let* ((*available-backend-node-temps* (bitclr *x862-arg-z* (bitclr x8664::rcx *available-backend-node-temps*))))
    50145093                  (! unbind-interrupt-level-inline))
    50155094                (! unbind-interrupt-level)))
     
    50545133        (if enclosing-ea
    50555134          (progn
    5056             (x862-store-ea seg enclosing-ea x8664::arg_z)
     5135            (x862-store-ea seg enclosing-ea *x862-arg-z*)
    50575136            (! destructuring-bind-inner))
    50585137          (! destructuring-bind)))
     
    52205299          (:insert-mmx-rm
    52215300           (x86::insert-mmx-rm-entry instruction
    5222                                      (svref register-table operand))))))
     5301                                     (svref register-table operand)))
     5302          (:insert-self
     5303           (setf (x86::x86-immediate-operand-type immediate-operand)
     5304                 (x86::encode-operand-type :self)
     5305                 (x86::x86-immediate-operand-value immediate-operand)
     5306                 (parse-x86-lap-expression operand)
     5307                 (x86::x86-instruction-imm instruction)
     5308                 immediate-operand)))))
    52235309    (x86-generate-instruction-code frag-list instruction)))
    52245310         
     
    54095495        (progn
    54105496          (! call-subprim subprim)
    5411           (<- ($ x8664::arg_z))
     5497          (<- ($ *x862-arg-z*))
    54125498          (^))))))
    54135499
    54145500(defun x862-unary-builtin (seg vreg xfer name form)
    54155501  (with-x86-local-vinsn-macros (seg)
    5416     (x862-one-targeted-reg-form seg form ($ x8664::arg_z))
     5502    (x862-one-targeted-reg-form seg form ($ *x862-arg-z*))
    54175503    (x862-fixed-call-builtin seg vreg xfer name (subprim-name->offset '.SPcallbuiltin1))))
    54185504
    54195505(defun x862-binary-builtin (seg vreg xfer name form1 form2)
    54205506  (with-x86-local-vinsn-macros (seg)
    5421     (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z))
     5507    (target-arch-case
     5508     (:x8632
     5509      (x862-two-targeted-reg-forms seg form1 ($ x8632::arg_y) form2 ($ x8632::arg_z)))
     5510     (:x8664
     5511      (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*))))
    54225512    (x862-fixed-call-builtin seg vreg xfer name (subprim-name->offset '.SPcallbuiltin2))))
    54235513
    54245514(defun x862-ternary-builtin (seg vreg xfer name form1 form2 form3)
    54255515  (with-x86-local-vinsn-macros (seg)
    5426     (x862-three-targeted-reg-forms seg form1 ($ x8664::arg_x) form2 ($ x8664::arg_y) form3 ($ x8664::arg_z))
     5516    (x862-three-targeted-reg-forms seg form1 ($ x8664::arg_x) form2 ($ *x862-arg-y*) form3 ($ *x862-arg-z*))
    54275517    (x862-fixed-call-builtin seg vreg xfer name (subprim-name->offset '.SPcallbuiltin3))))
    54285518
     
    56155705            (do* ((vars arg-regs (cdr vars))
    56165706                  (arg-reg-numbers (target-arch-case
    5617                                     (:x8664 (list x8664::arg_z x8664::arg_y x8664::arg_x))))
     5707                                    (:x8664 (list x8664::arg_z *x862-arg-y* x8664::arg_x))))
    56185708                  (arg-reg-num (pop arg-reg-numbers) (pop arg-reg-numbers)))
    56195709                 ((null vars))
     
    56895779        (x862-push-register seg
    56905780                            (if (or node-p crf-p)
    5691                               (x862-one-untargeted-reg-form seg first x8664::arg_z)
     5781                              (x862-one-untargeted-reg-form seg first *x862-arg-z*)
    56925782                              (x862-one-targeted-reg-form seg first vreg)))
    56935783        (dolist (form forms)
     
    56955785        (if crf-p
    56965786          (progn
    5697             (x862-vpop-register seg x8664::arg_z)
    5698             (<- x8664::arg_z))
     5787            (x862-vpop-register seg *x862-arg-z*)
     5788            (<- *x862-arg-z*))
    56995789          (x862-pop-register seg vreg))
    57005790        (^)))))
     
    57105800
    57115801(defx862 x862-%slot-ref %slot-ref (seg vreg xfer instance idx)
    5712   (ensuring-node-target (target (or vreg ($ x8664::arg_z)))
     5802  (ensuring-node-target (target (or vreg ($ *x862-arg-z*)))
    57135803    (multiple-value-bind (v i)
    5714         (x862-two-untargeted-reg-forms seg instance x8664::arg_y idx x8664::arg_z)
     5804        (x862-two-untargeted-reg-forms seg instance *x862-arg-y* idx *x862-arg-z*)
    57155805      (unless *x862-reckless*
    57165806        (! check-misc-bound i v))
     
    57535843    (let* ((tagreg x8664::imm0))
    57545844      (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    5755         (! extract-fulltag tagreg (x862-one-untargeted-reg-form seg form x8664::arg_z))
     5845        (! extract-fulltag tagreg (x862-one-untargeted-reg-form seg form *x862-arg-z*))
    57565846        (! compare-u8-constant tagreg x8664::fulltag-cons)
    57575847        (regspec-crf-gpr-case
     
    57705860      (x862-form seg nil nil y)
    57715861      (x862-form seg nil xfer z))
    5772     (multiple-value-bind (yreg zreg) (x862-two-untargeted-reg-forms seg y x8664::arg_y z x8664::arg_z)
     5862    (multiple-value-bind (yreg zreg) (x862-two-untargeted-reg-forms seg y *x862-arg-y* z *x862-arg-z*)
    57735863      (ensuring-node-target (target vreg)
    57745864        (! cons target yreg zreg))
     
    58285918            (x862-set-nargs seg (x862-formlist seg all-on-stack nil))
    58295919            (! gvector))
    5830           (<- x8664::arg_z)
     5920          (<- *x862-arg-z*)
    58315921          (^))
    58325922        (x862-allocate-initialized-gvector seg vreg xfer subtag (cdr all-on-stack))))))
     
    58545944            (x862-one-targeted-reg-form seg otherform target)
    58555945            (! %logior-c target target (ash fixval *x862-target-fixnum-shift*))))
    5856          (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     5946         (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    58575947            (if vreg (ensuring-node-target (target vreg) (! %logior2 target r1 r2)))))
    58585948      (^))))
     
    58765966            (x862-one-targeted-reg-form seg otherform target)
    58775967            (! %logand-c target target (ash fixval *x862-target-fixnum-shift*))))
    5878          (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     5968         (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    58795969            (if vreg (ensuring-node-target (target vreg) (! %logand2 target r1 r2)))))
    58805970      (^))))
     
    58955985            (x862-one-targeted-reg-form seg otherform target)
    58965986            (! %logxor-c target target (ash fixval *x862-target-fixnum-shift*))))
    5897          (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     5987         (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    58985988            (if vreg (ensuring-node-target (target vreg) (! %logxor2 target r1 r2)))))
    58995989      (^))))
     
    59316021(defx862 x862-istruct-typep istruct-typep (seg vreg xfer cc form type)
    59326022  (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    5933     (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form x8664::arg_y type x8664::arg_z)
     6023    (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form *x862-arg-y* type *x862-arg-z*)
    59346024      (! set-z-flag-if-istruct-typep r1 r2)
    59356025      (regspec-crf-gpr-case
     
    59506040    (progn
    59516041      (unboxed-other-case (vreg :u8)
    5952         (! extract-tag vreg (x862-one-untargeted-reg-form seg node x8664::arg_z))
     6042        (! extract-tag vreg (x862-one-untargeted-reg-form seg node *x862-arg-z*))
    59536043        (ensuring-node-target (target vreg)
    5954          (! extract-tag-fixnum target (x862-one-untargeted-reg-form seg node x8664::arg_z))))
     6044         (! extract-tag-fixnum target (x862-one-untargeted-reg-form seg node *x862-arg-z*))))
    59556045      (^))))
    59566046
     
    59616051    (progn
    59626052      (unboxed-other-case (vreg :u8)
    5963         (! extract-fulltag vreg (x862-one-untargeted-reg-form seg node x8664::arg_z))
     6053        (! extract-fulltag vreg (x862-one-untargeted-reg-form seg node *x862-arg-z*))
    59646054        (ensuring-node-target (target vreg)
    5965           (! extract-fulltag-fixnum target (x862-one-untargeted-reg-form seg node x8664::arg_z))))
     6055          (! extract-fulltag-fixnum target (x862-one-untargeted-reg-form seg node *x862-arg-z*))))
    59666056      (^))))
    59676057
     
    59726062    (progn
    59736063      (unboxed-other-case (vreg :u8)
    5974          (! extract-typecode vreg (x862-one-untargeted-reg-form seg node x8664::arg_z))
    5975          (let* ((reg (x862-one-untargeted-reg-form seg node (if (eq (hard-regspec-value vreg) x8664::arg_z)
    5976                                                               x8664::arg_y x8664::arg_z))))
     6064         (! extract-typecode vreg (x862-one-untargeted-reg-form seg node *x862-arg-z*))
     6065         (let* ((reg (x862-one-untargeted-reg-form seg node (if (eq (hard-regspec-value vreg) *x862-arg-z*)
     6066                                                              *x862-arg-y* *x862-arg-z*))))
    59776067           (ensuring-node-target (target vreg)
    59786068             (! extract-typecode-fixnum target reg ))))
     
    59806070
    59816071(defx862 x862-setq-special setq-special (seg vreg xfer sym val)
    5982   (let* ((symreg ($ x8664::arg_y))
    5983          (valreg ($ x8664::arg_z)))
     6072  (let* ((symreg ($ *x862-arg-y*))
     6073         (valreg ($ *x862-arg-z*)))
    59846074    (x862-one-targeted-reg-form seg val valreg)
    59856075    (x862-store-immediate seg (x862-symbol-value-cell sym) symreg)
     
    60086098         end-of-block
    60096099         last-cd
    6010          (dest (if (backend-crf-p vreg) x8664::arg_z vreg)))
     6100         (dest (if (backend-crf-p vreg) *x862-arg-z* vreg)))
    60116101    (if need-label
    60126102      (setq end-of-block (backend-get-next-label)))
     
    60286118
    60296119(defx862 x862-uvsize uvsize (seg vreg xfer v)
    6030   (let* ((misc-reg (x862-one-untargeted-reg-form seg v x8664::arg_z)))
     6120  (let* ((misc-reg (x862-one-untargeted-reg-form seg v *x862-arg-z*)))
    60316121    (unless *x862-reckless* (! trap-unless-uvector misc-reg))
    60326122    (if vreg
     
    60446134      (ensuring-node-target (target vreg)
    60456135        (if const
    6046           (let* ((src (x862-one-untargeted-reg-form seg form2 x8664::arg_z)))
     6136          (let* ((src (x862-one-untargeted-reg-form seg form2 *x862-arg-z*)))
    60476137            (if (<= const max)
    60486138              (! %ilsl-c target const src)
    60496139              (!  lri target 0)))
    6050           (multiple-value-bind (count src) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     6140          (multiple-value-bind (count src) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    60516141            (! %ilsl target count src))))
    60526142      (^))))
    60536143
    60546144(defx862 x862-endp endp (seg vreg xfer cc form)
    6055   (let* ((formreg (x862-one-untargeted-reg-form seg form x8664::arg_z)))
     6145  (let* ((formreg (x862-one-untargeted-reg-form seg form *x862-arg-z*)))
    60566146    (! trap-unless-list formreg)
    60576147    (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
     
    60716161(defx862 x862-%schar %schar (seg vreg xfer str idx)
    60726162  (multiple-value-bind (src unscaled-idx)
    6073       (x862-two-untargeted-reg-forms seg str x8664::arg_y idx x8664::arg_z)
     6163      (x862-two-untargeted-reg-forms seg str *x862-arg-y* idx *x862-arg-z*)
    60746164    (if vreg
    60756165      (ensuring-node-target (target vreg)
     
    60836173      (x862-three-untargeted-reg-forms seg
    60846174                                       str x8664::arg_x
    6085                                        idx x8664::arg_y
    6086                                        char x8664::arg_z)
     6175                                       idx *x862-arg-y*
     6176                                       char *x862-arg-z*)
    60876177    (case (arch::target-char-code-limit (backend-target-arch *target-backend*))
    60886178      (256 (! %set-schar8 src unscaled-idx char))
     
    60936183(defx862 x862-%set-scharcode %set-scharcode (seg vreg xfer str idx char)
    60946184  (multiple-value-bind (src unscaled-idx char)
    6095       (x862-three-untargeted-reg-forms seg str x8664::arg_x idx x8664::arg_y
    6096                                        char x8664::arg_z)
     6185      (x862-three-untargeted-reg-forms seg str x8664::arg_x idx *x862-arg-y*
     6186                                       char *x862-arg-z*)
    60976187    (case (arch::target-char-code-limit (backend-target-arch *target-backend*))
    60986188      (256 (! %set-scharcode8 src unscaled-idx char))
     
    61036193(defx862 x862-%scharcode %scharcode (seg vreg xfer str idx)
    61046194  (multiple-value-bind (src unscaled-idx)
    6105       (x862-two-untargeted-reg-forms seg str x8664::arg_y idx x8664::arg_z)
     6195      (x862-two-untargeted-reg-forms seg str *x862-arg-y* idx *x862-arg-z*)
    61066196    (if vreg
    61076197      (ensuring-node-target (target vreg)
     
    61146204
    61156205(defx862 x862-code-char code-char (seg vreg xfer c)
    6116   (let* ((reg (x862-one-untargeted-reg-form seg c x8664::arg_z)))
     6206  (let* ((reg (x862-one-untargeted-reg-form seg c *x862-arg-z*)))
    61176207    ;; Typecheck even if result unused.
    61186208    (! require-char-code reg)
     
    61546244           (done (backend-get-next-label)))
    61556245      (if otherform
    6156         (x862-one-targeted-reg-form seg otherform ($ x8664::arg_y))
    6157         (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z)))
     6246        (x862-one-targeted-reg-form seg otherform ($ *x862-arg-y*))
     6247        (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*)))
    61586248      (if otherform
    61596249        (unless (acode-fixnum-form-p otherform)
    6160           (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)))
     6250          (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)))
    61616251        (if (acode-fixnum-form-p form1)
    6162           (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
     6252          (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
    61636253          (if (acode-fixnum-form-p form2)
    6164             (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6165             (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line)))))
     6254            (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6255            (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))))
    61666256      (if otherform
    61676257        (if (zerop fixval)
    6168           (! compare-reg-to-zero ($ x8664::arg_y))
    6169           (! compare-s32-constant ($ x8664::arg_y) (ash fixval x8664::fixnumshift)))
    6170         (! compare ($ x8664::arg_y) ($ x8664::arg_z)))
     6258          (! compare-reg-to-zero ($ *x862-arg-y*))
     6259          (! compare-s32-constant ($ *x862-arg-y*) (ash fixval x8664::fixnumshift)))
     6260        (! compare ($ *x862-arg-y*) ($ *x862-arg-z*)))
    61716261      (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    61726262        (when otherform
     
    61756265        (if (not true-p)
    61766266          (setq cr-bit (logxor 1 cr-bit)))
    6177         (! cr-bit->boolean ($ x8664::arg_z) cr-bit)
     6267        (! cr-bit->boolean ($ *x862-arg-z*) cr-bit)
    61786268        (-> done)
    61796269        (@ out-of-line)
    61806270        (when otherform
    6181           (x862-lri seg ($ x8664::arg_z) (ash fixval x8664::fixnumshift))
     6271          (x862-lri seg ($ *x862-arg-z*) (ash fixval x8664::fixnumshift))
    61826272          (unless (or fix2 (eq cr-bit x86::x86-e-bits))
    6183             (! xchg-registers ($ x8664::arg_z) ($ x8664::arg_y))))
     6273            (! xchg-registers ($ *x862-arg-z*) ($ *x862-arg-y*))))
    61846274        (let* ((index (arch::builtin-function-name-offset name))
    61856275               (idx-subprim (x862-builtin-index-subprim index)))
    6186           (! call-subprim-2 ($ x8664::arg_z) idx-subprim ($ x8664::arg_y) ($ x8664::arg_z)))
     6276          (! call-subprim-2 ($ *x862-arg-z*) idx-subprim ($ *x862-arg-y*) ($ *x862-arg-z*)))
    61876277        (@ done)
    6188         (<- ($ x8664::arg_z))
     6278        (<- ($ *x862-arg-z*))
    61896279        (^)))))
    61906280         
     
    61976287    (progn
    61986288      (ensuring-node-target (target vreg)
    6199         (! sign-extend-halfword target (x862-one-untargeted-reg-form seg form x8664::arg_z)))
     6289        (! sign-extend-halfword target (x862-one-untargeted-reg-form seg form *x862-arg-z*)))
    62006290      (^))))
    62016291
     
    62046294  (! list)
    62056295  (when vreg
    6206     (<- x8664::arg_z))
     6296    (<- *x862-arg-z*))
    62076297  (^))
    62086298
     
    62436333                                                                   (or (null vreg) (eq ea vreg)))
    62446334                                                            ea
    6245                                                             x8664::arg_z))))
     6335                                                            *x862-arg-z*))))
    62466336      (x862-do-lexical-setq seg vreg ea valreg))
    62476337    (^)))
     
    62866376      (let* ((fixbit (acode-fixnum-form-p bitnum)))
    62876377        (if fixbit
    6288           (let* ((reg (x862-one-untargeted-reg-form seg form x8664::arg_z))
     6378          (let* ((reg (x862-one-untargeted-reg-form seg form *x862-arg-z*))
    62896379                 (x86-bit (min (+ fixbit *x862-target-fixnum-shift*) (1- *x862-target-bits-in-word*))))
    62906380            (! set-c-flag-if-constant-logbitp x86-bit reg))
    6291           (multiple-value-bind (rbit rform) (x862-two-untargeted-reg-forms seg bitnum x8664::arg_y form x8664::arg_z)
     6381          (multiple-value-bind (rbit rform) (x862-two-untargeted-reg-forms seg bitnum *x862-arg-y* form *x862-arg-z*)
    62926382            (! set-c-flag-if-variable-logbitp rbit rform)))
    62936383        (regspec-crf-gpr-case
     
    63036393
    63046394(defx862 x862-uvref uvref (seg vreg xfer vector index)
    6305   (x862-two-targeted-reg-forms seg vector ($ x8664::arg_y) index ($ x8664::arg_z))
     6395  (x862-two-targeted-reg-forms seg vector ($ *x862-arg-y*) index ($ *x862-arg-z*))
    63066396  (! misc-ref)
    6307   (<- ($ x8664::arg_z))
     6397  (<- ($ *x862-arg-z*))
    63086398  (^))
    63096399
    63106400(defx862 x862-uvset uvset (seg vreg xfer vector index value)
    6311   (x862-three-targeted-reg-forms seg vector ($ x8664::arg_x) index ($ x8664::arg_y) value ($ x8664::arg_z))
     6401  (x862-three-targeted-reg-forms seg vector ($ x8664::arg_x) index ($ *x862-arg-y*) value ($ *x862-arg-z*))
    63126402  (! misc-set)
    6313   (<- ($ x8664::arg_z))
     6403  (<- ($ *x862-arg-z*))
    63146404  (^))
    63156405
     
    63756465      (progn
    63766466        (! call-subprim subprim)
    6377         (<- x8664::arg_z)
     6467        (<- *x862-arg-z*)
    63786468        (^)))))
    63796469     
     
    64046494        (setq xfer nil))
    64056495      (if both-single-valued            ; it's implied that we're returning
    6406         (let* ((result x8664::arg_z))
     6496        (let* ((result *x862-arg-z*))
    64076497          (let ((merge-else-branch-label (if (nx-null false) (x862-find-nilret-label))))
    64086498            (x862-conditional-form seg (x862-make-compound-cd 0 falselabel) testform)
     
    64756565         (vstack *x862-vstack*)
    64766566         (cstack *x862-cstack*)
    6477          (dest (if (backend-crf-p vreg) vreg (if vreg x8664::arg_z (available-crf-temp *available-backend-crf-temps*))))
     6567         (dest (if (backend-crf-p vreg) vreg (if vreg *x862-arg-z* (available-crf-temp *available-backend-crf-temps*))))
    64786568         (cd1 (x862-make-compound-cd
    6479                (if (eq dest x8664::arg_z) tag1 (x862-cd-merge (x862-cd-true xfer) tag1)) 0)))
     6569               (if (eq dest *x862-arg-z*) tag1 (x862-cd-merge (x862-cd-true xfer) tag1)) 0)))
    64806570    (while (cdr forms)
    6481       (x862-form seg dest (if (eq dest x8664::arg_z) nil cd1) (car forms))
    6482       (when (eq dest x8664::arg_z)
     6571      (x862-form seg dest (if (eq dest *x862-arg-z*) nil cd1) (car forms))
     6572      (when (eq dest *x862-arg-z*)
    64836573        (with-crf-target () val-crf
    64846574          (x862-copy-register seg val-crf dest)
     
    64886578      (progn (x862-multiple-value-body seg (car forms))
    64896579             (let* ((*x862-returning-values* t)) (x862-branch seg (x862-cd-merge xfer tag2))))
    6490       (x862-form seg  vreg (if (eq dest x8664::arg_z) (x862-cd-merge xfer tag2) xfer) (car forms)))
     6580      (x862-form seg  vreg (if (eq dest *x862-arg-z*) (x862-cd-merge xfer tag2) xfer) (car forms)))
    64916581    (setq *x862-vstack* vstack *x862-cstack* cstack)
    64926582    (@ tag1)
    6493     (when (eq dest x8664::arg_z)
    6494       (<- x8664::arg_z)
     6583    (when (eq dest *x862-arg-z*)
     6584      (<- *x862-arg-z*)
    64956585      (^))
    64966586    (@ tag2)))
     
    65086598      (x862-set-nargs seg nargs)
    65096599      (! list)
    6510       (<- x8664::arg_z)))
     6600      (<- *x862-arg-z*)))
    65116601  (^))
    65126602
     
    65226612        (x862-set-nargs seg (1- nargs))
    65236613        (! list*))
    6524       (<- x8664::arg_z)))
     6614      (<- *x862-arg-z*)))
    65256615  (^))
    65266616
     
    65406630      (x862-inline-add2 seg vreg xfer form1 (make-acode (%nx1-operator fixnum) (- v2)))
    65416631      (with-x86-local-vinsn-macros (seg vreg xfer)
    6542         (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z))
     6632        (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*))
    65436633    (let* ((out-of-line (backend-get-next-label))
    65446634           (done (backend-get-next-label)))
    65456635      (ensuring-node-target (target vreg)
    65466636        (if (acode-fixnum-form-p form1)
    6547           (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
     6637          (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
    65486638          (if (acode-fixnum-form-p form2)
    6549             (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6550             (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line))))
    6551         (! fixnum-sub2 ($ x8664::arg_z) ($ x8664::arg_y) ($ x8664::arg_z))
    6552         (x862-check-fixnum-overflow seg ($ x8664::arg_z) done)
     6639            (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6640            (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line))))
     6641        (! fixnum-sub2 ($ *x862-arg-z*) ($ *x862-arg-y*) ($ *x862-arg-z*))
     6642        (x862-check-fixnum-overflow seg ($ *x862-arg-z*) done)
    65536643        (@ out-of-line)
    6554         (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPbuiltin-minus) ($ x8664::arg_y) ($ x8664::arg_z))
     6644        (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPbuiltin-minus) ($ *x862-arg-y*) ($ *x862-arg-z*))
    65556645        (@ done)
    6556         (x862-copy-register seg target ($ x8664::arg_z)))
     6646        (x862-copy-register seg target ($ *x862-arg-z*)))
    65576647      (^))))))
    65586648
     
    65606650  (with-x86-local-vinsn-macros (seg vreg xfer)
    65616651    (let* ((fix1 (acode-fixnum-form-p form1))
    6562            (fix2 (acode-fixnum-form-p form2))
    6563            (otherform (if (and fix1
    6564                                (typep (ash fix1 *x862-target-fixnum-shift*)
    6565                                       '(signed-byte 32)))
    6566                         form2
    6567                         (if (and fix2
    6568                                 (typep (ash fix2 *x862-target-fixnum-shift*)
    6569                                         '(signed-byte 32)))
    6570                           form1))))
     6652           (fix2 (acode-fixnum-form-p form2))
     6653           (otherform (if (and fix1
     6654                               (typep (ash fix1 *x862-target-fixnum-shift*)
     6655                                      '(signed-byte 32)))
     6656                        form2
     6657                        (if (and fix2
     6658                                (typep (ash fix2 *x862-target-fixnum-shift*)
     6659                                        '(signed-byte 32)))
     6660                          form1))))
    65716661      (if otherform
    6572         (x862-one-targeted-reg-form seg otherform ($ x8664::arg_z))
    6573         (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z)))
     6662        (x862-one-targeted-reg-form seg otherform ($ *x862-arg-z*))
     6663        (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*)))
    65746664      (let* ((out-of-line (backend-get-next-label))
    6575              (done (backend-get-next-label)))
    6576      
    6577         (ensuring-node-target (target vreg)
    6578           (if otherform
    6579             (unless (acode-fixnum-form-p otherform)
    6580               (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line)))         
    6581             (if (acode-fixnum-form-p form1)
    6582               (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
    6583               (if (acode-fixnum-form-p form2)
    6584                 (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6585                 (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line)))))
    6586           (if otherform
    6587             (! add-constant ($ x8664::arg_z) (ash (or fix1 fix2) *x862-target-fixnum-shift*))
    6588             (! fixnum-add2 ($ x8664::arg_z) ($ x8664::arg_y)))
    6589           (x862-check-fixnum-overflow seg ($ x8664::arg_z) done)
    6590           (@ out-of-line)
    6591           (if otherform
    6592             (x862-lri seg ($ x8664::arg_y) (ash (or fix1 fix2) *x862-target-fixnum-shift*)))
    6593           (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPbuiltin-plus) ($ x8664::arg_y) ($ x8664::arg_z))
    6594           (@ done)
    6595           (x862-copy-register seg target ($ x8664::arg_z)))
    6596         (^)))))
     6665             (done (backend-get-next-label)))
     6666       
     6667        (ensuring-node-target (target vreg)
     6668          (if otherform
     6669            (unless (acode-fixnum-form-p otherform)
     6670              (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))         
     6671            (if (acode-fixnum-form-p form1)
     6672              (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
     6673              (if (acode-fixnum-form-p form2)
     6674                (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6675                (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))))
     6676          (if otherform
     6677            (! add-constant ($ *x862-arg-z*) (ash (or fix1 fix2) *x862-target-fixnum-shift*))
     6678            (! fixnum-add2 ($ *x862-arg-z*) ($ *x862-arg-y*)))
     6679          (x862-check-fixnum-overflow seg ($ *x862-arg-z*) done)
     6680          (@ out-of-line)
     6681          (if otherform
     6682            (x862-lri seg ($ *x862-arg-y*) (ash (or fix1 fix2) *x862-target-fixnum-shift*)))
     6683          (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPbuiltin-plus) ($ *x862-arg-y*) ($ *x862-arg-z*))
     6684          (@ done)
     6685          (x862-copy-register seg target ($ *x862-arg-z*)))
     6686        (^)))))
    65976687           
    65986688(defx862 x862-add2 add2 (seg vreg xfer form1 form2)
     
    67386828            (ensuring-node-target (target vreg)
    67396829              (if otherform
    6740                 (x862-one-targeted-reg-form seg otherform ($ x8664::arg_z))
    6741                 (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z)))
     6830                (x862-one-targeted-reg-form seg otherform ($ *x862-arg-z*))
     6831                (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*)))
    67426832              (if otherform
    67436833                (unless (acode-fixnum-form-p otherform)
    6744                   (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line)))
     6834                  (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))
    67456835                (if (acode-fixnum-form-p form1)
    6746                   (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
     6836                  (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
    67476837                  (if (acode-fixnum-form-p form2)
    6748                     (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6749                     (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line)))))
     6838                    (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6839                    (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))))
    67506840              (if otherform
    6751                 (! %logior-c ($ x8664::arg_z) ($ x8664::arg_z) (ash fixval x8664::fixnumshift))
    6752                 (! %logior2 ($ x8664::arg_z) ($ x8664::arg_z) ($ x8664::arg_y)))
     6841                (! %logior-c ($ *x862-arg-z*) ($ *x862-arg-z*) (ash fixval x8664::fixnumshift))
     6842                (! %logior2 ($ *x862-arg-z*) ($ *x862-arg-z*) ($ *x862-arg-y*)))
    67536843              (-> done)
    67546844              (@ out-of-line)
    67556845              (if otherform
    6756                 (x862-lri seg ($ x8664::arg_y) (ash fixval x8664::fixnumshift)))
    6757               (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPbuiltin-logior) ($ x8664::arg_y) ($ x8664::arg_z))
     6846                (x862-lri seg ($ *x862-arg-y*) (ash fixval x8664::fixnumshift)))
     6847              (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPbuiltin-logior) ($ *x862-arg-y*) ($ *x862-arg-z*))
    67586848              (@ done)
    6759               (x862-copy-register seg target ($ x8664::arg_z)))
     6849              (x862-copy-register seg target ($ *x862-arg-z*)))
    67606850            (^)))))))
    67616851
     
    67836873            (ensuring-node-target (target vreg)
    67846874              (if otherform
    6785                 (x862-one-targeted-reg-form seg otherform ($ x8664::arg_z))
    6786                 (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z)))
     6875                (x862-one-targeted-reg-form seg otherform ($ *x862-arg-z*))
     6876                (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*)))
    67876877              (if otherform
    67886878                (unless (acode-fixnum-form-p otherform)
    6789                   (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line)))
     6879                  (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))
    67906880                (if (acode-fixnum-form-p form1)
    6791                   (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
     6881                  (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
    67926882                  (if (acode-fixnum-form-p form2)
    6793                     (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6794                     (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line)))))
     6883                    (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6884                    (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))))
    67956885              (if otherform
    6796                 (! %logand-c ($ x8664::arg_z) ($ x8664::arg_z) (ash fixval x8664::fixnumshift))
    6797                 (! %logand2 ($ x8664::arg_z) ($ x8664::arg_z) ($ x8664::arg_y)))
     6886                (! %logand-c ($ *x862-arg-z*) ($ *x862-arg-z*) (ash fixval x8664::fixnumshift))
     6887                (! %logand2 ($ *x862-arg-z*) ($ *x862-arg-z*) ($ *x862-arg-y*)))
    67986888              (-> done)
    67996889              (@ out-of-line)
    68006890              (if otherform
    6801                 (x862-lri seg ($ x8664::arg_y) (ash fixval x8664::fixnumshift)))
    6802               (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPbuiltin-logand) ($ x8664::arg_y) ($ x8664::arg_z))
     6891                (x862-lri seg ($ *x862-arg-y*) (ash fixval x8664::fixnumshift)))
     6892              (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPbuiltin-logand) ($ *x862-arg-y*) ($ *x862-arg-z*))
    68036893              (@ done)
    6804               (x862-copy-register seg target ($ x8664::arg_z)))
     6894              (x862-copy-register seg target ($ *x862-arg-z*)))
    68056895            (^)))))))
    68066896
     
    68856975                         (! add-constant3 target reg constant))))))
    68866976               (if (not overflow)
    6887                  (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     6977                 (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    68886978                   ;; This isn't guaranteed to set the overflow flag,
    68896979                   ;; but may do so.
     
    68916981                     (! fixnum-add3 target r1 r2)))
    68926982                 (ensuring-node-target (target vreg)
    6893                    (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     6983                   (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    68946984                     (cond ((= (hard-regspec-value target)
    68956985                               (hard-regspec-value r1))
     
    69257015              (if (and fix1 fix2 (not overflow))
    69267016                (x862-lri seg vreg (ash (- fix1 fix2) *x862-target-fixnum-shift*))
    6927                 (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg num1 x8664::arg_y num2 x8664::arg_z)
     7017                (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg num1 *x862-arg-y* num2 *x862-arg-z*)
    69287018                      ;; This isn't guaranteed to set the overflow flag,
    69297019                      ;; but may do so.
     
    69457035        (x862-lri seg vreg (ash (* fix1 fix2) *x862-target-fixnum-shift*))
    69467036        (if other
    6947           (! multiply-immediate vreg (x862-one-untargeted-reg-form seg other x8664::arg_z) (or fix1 fix2))
    6948           (multiple-value-bind (rx ry) (x862-two-untargeted-reg-forms seg num1 x8664::arg_y num2 x8664::arg_z)
     7037          (! multiply-immediate vreg (x862-one-untargeted-reg-form seg other *x862-arg-z*) (or fix1 fix2))
     7038          (multiple-value-bind (rx ry) (x862-two-untargeted-reg-forms seg num1 *x862-arg-y* num2 *x862-arg-z*)
    69497039            (ensuring-node-target (target vreg)
    69507040              (! multiply-fixnums target rx ry)))))
     
    69547044  (let* ((*x862-vstack* *x862-vstack*)
    69557045         (*x862-top-vstack-lcell* *x862-top-vstack-lcell*))
    6956     (let* ((nreg (x862-one-untargeted-reg-form seg n x8664::arg_z)))
     7046    (let* ((nreg (x862-one-untargeted-reg-form seg n *x862-arg-z*)))
    69577047      (unless (acode-fixnum-form-p n)
    69587048        (! trap-unless-fixnum nreg))
    69597049      (x862-vpush-register seg nreg))
    69607050     (x862-multiple-value-body seg form) ; sets nargs
    6961     (! nth-value x8664::arg_z))
    6962   (<- x8664::arg_z)
     7051    (! nth-value *x862-arg-z*))
     7052  (<- *x862-arg-z*)
    69637053  (^))
    69647054
     
    69877077  (with-x86-local-vinsn-macros (seg vreg xfer)
    69887078    (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    6989       (! mask-base-char x8664::imm0 (x862-one-untargeted-reg-form seg form x8664::arg_z))
     7079      (! mask-base-char x8664::imm0 (x862-one-untargeted-reg-form seg form *x862-arg-z*))
    69907080      (x862-test-reg-%izerop seg vreg xfer x8664::imm0 cr-bit true-p
    69917081                             (target-arch-case
     
    70697159         vreg
    70707160         xfer
    7071          (x862-one-untargeted-reg-form seg form x8664::arg_z)
     7161         (x862-one-untargeted-reg-form seg form *x862-arg-z*)
    70727162         cr-bit
    70737163         true-p)))))
     
    70967186          (if initval
    70977187            (progn
    7098               (x862-three-targeted-reg-forms seg element-count ($ x8664::arg_x) st ($ x8664::arg_y) initval ($ x8664::arg_z))
     7188              (x862-three-targeted-reg-forms seg element-count ($ x8664::arg_x) st ($ *x862-arg-y*) initval ($ *x862-arg-z*))
    70997189              (! misc-alloc-init)
    7100               (<- ($ x8664::arg_z)))
     7190              (<- ($ *x862-arg-z*)))
    71017191            (progn
    7102               (x862-two-targeted-reg-forms seg element-count ($ x8664::arg_y) st ($ x8664::arg_z))
     7192              (x862-two-targeted-reg-forms seg element-count ($ *x862-arg-y*) st ($ *x862-arg-z*))
    71037193              (! misc-alloc)
    7104               (<- ($ x8664::arg_z))))))
     7194              (<- ($ *x862-arg-z*))))))
    71057195        (^))))
    71067196
     
    71167206        (if count
    71177207          (! %iasr-c target (if (> count max) max count)
    7118              (x862-one-untargeted-reg-form seg form2 x8664::arg_z))
    7119           (multiple-value-bind (cnt src) (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z))
     7208             (x862-one-untargeted-reg-form seg form2 *x862-arg-z*))
     7209          (multiple-value-bind (cnt src) (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*))
    71207210            (! %iasr target cnt src))))
    71217211      (^))))
     
    71297219      (ensuring-node-target (target vreg)
    71307220        (if count
    7131           (let ((src (x862-one-untargeted-reg-form seg form2 ($ x8664::arg_z))))
     7221          (let ((src (x862-one-untargeted-reg-form seg form2 ($ *x862-arg-z*))))
    71327222            (if (<= count 31)
    71337223              (! %ilsr-c target count src)
    71347224              (!  lri target 0)))
    7135           (multiple-value-bind (cnt src) (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z))
     7225          (multiple-value-bind (cnt src) (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*))
    71367226            (! %ilsr target cnt src))))
    71377227      (^))))
     
    72377327                   (x862-two-targeted-reg-forms seg
    72387328                                                ptr ptrreg
    7239                                                 offset ($ x8664::arg_z))
    7240                    (! fixnum->signed-natural offsetreg x8664::arg_z)
     7329                                                offset ($ *x862-arg-z*))
     7330                   (! fixnum->signed-natural offsetreg *x862-arg-z*)
    72417331                   (if double-p
    72427332                     (! mem-ref-double-float fp-reg ptrreg offsetreg)
     
    72837373                         (x862-one-untargeted-reg-form seg
    72847374                                                       offset
    7285                                                        x8664::arg_z))
     7375                                                       *x862-arg-z*))
    72867376                        (x862-one-targeted-reg-form seg newval fp-reg)
    7287                         (x862-pop-register seg x8664::arg_z)
     7377                        (x862-pop-register seg *x862-arg-z*)
    72887378                        (x862-pop-register seg ptr-reg)
    7289                         (! fixnum->signed-natural offset-reg x8664::arg_z)
     7379                        (! fixnum->signed-natural offset-reg *x862-arg-z*)
    72907380                        (if double-p
    72917381                          (! mem-set-double-float fp-reg ptr-reg offset-reg)
     
    72947384              (t
    72957385               (cond (immoffset
    7296                       (let* ((rnew ($ x8664::arg_z)))
     7386                      (let* ((rnew ($ *x862-arg-z*)))
    72977387                        (x862-push-register
    72987388                         seg
     
    73087398                            (! mem-set-c-single-float fp-reg ptr-reg fixoffset)))))
    73097399                     (t
    7310                       (let* ((roffset ($ x8664::arg_y))
    7311                              (rnew ($ x8664::arg_z)))
     7400                      (let* ((roffset ($ *x862-arg-y*))
     7401                             (rnew ($ *x862-arg-z*)))
    73127402                        (x862-push-register
    73137403                         seg
     
    73267416                          (! mem-set-double-float fp-reg ptr-reg offset-reg)
    73277417                          (! mem-set-single-float fp-reg ptr-reg offset-reg))))))
    7328                (<- x8664::arg_z)))
     7418               (<- *x862-arg-z*)))
    73297419        (^)))))
    73307420
     
    73667456                     (if (acode-fixnum-form-p offset)
    73677457                       (x862-lri seg x (acode-fixnum-form-p offset))
    7368                        (! fixnum->signed-natural x (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7458                       (! fixnum->signed-natural x (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    73697459                     (! mem-ref-natural dest src x))
    73707460                   (progn
    73717461                     (! temp-push-unboxed-word src)
    73727462                     (x862-open-undo $undostkblk)
    7373                      (let* ((oreg (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7463                     (let* ((oreg (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    73747464                       (with-imm-temps () (src x)
    73757465                         (! temp-pop-unboxed-word src)
     
    73957485              (<- dest))))
    73967486        (with-imm-target () (src-reg :address)
    7397           (x862-two-targeted-reg-forms seg ptr src-reg offset ($ x8664::arg_z))
     7487          (x862-two-targeted-reg-forms seg ptr src-reg offset ($ *x862-arg-z*))
    73987488          (if (node-reg-p vreg)
    7399             (! mem-ref-bit-fixnum vreg src-reg ($ x8664::arg_z))
     7489            (! mem-ref-bit-fixnum vreg src-reg ($ *x862-arg-z*))
    74007490            (with-imm-target ()           ;OK if src-reg & dest overlap
    74017491                (dest :u8)
     
    74527542                         (if (acode-fixnum-form-p offset)
    74537543                           (x862-lri seg offset-reg (acode-fixnum-form-p offset))
    7454                            (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7544                           (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    74557545                         (progn
    74567546                           (! temp-push-unboxed-word src-reg)
    74577547                           (x862-open-undo $undostkblk)
    7458                            (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z))
     7548                           (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*))
    74597549                           (! temp-pop-unboxed-word src-reg)
    74607550                           (x862-close-undo)))
     
    74897579                       (if (acode-fixnum-form-p offset)
    74907580                         (x862-lri seg offset-reg (acode-fixnum-form-p offset))
    7491                          (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7581                         (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    74927582                       (progn
    74937583                         (! temp-push-unboxed-word src-reg)
    74947584                         (x862-open-undo $undostkblk)
    7495                          (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z))
     7585                         (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*))
    74967586                         (! temp-pop-unboxed-word src-reg)
    74977587                         (x862-close-undo)))
     
    75337623                       (if (acode-fixnum-form-p offset)
    75347624                         (x862-lri seg offset-reg (acode-fixnum-form-p offset))
    7535                          (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7625                         (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    75367626                       (progn
    75377627                         (! temp-push-unboxed-word src-reg)
    75387628                         (x862-open-undo $undostkblk)
    7539                          (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z))
     7629                         (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*))
    75407630                         (! temp-pop-unboxed-word src-reg)
    75417631                         (x862-close-undo)))
     
    75777667                     (%rplaca pair (x862-vloc-ea *x862-vstack*))
    75787668                     (x862-vpush-register seg val :reserved))
    7579                  (x862-vpush-register seg (x862-one-untargeted-reg-form seg val x8664::arg_z) :reserved))
     7669                 (x862-vpush-register seg (x862-one-untargeted-reg-form seg val *x862-arg-z*) :reserved))
    75807670                 (%rplacd pair *x862-top-vstack-lcell*)))
    75817671              (t (x862-seq-bind-var seg var val)
     
    75977687(defx862 x862-closed-function closed-function (seg vreg xfer afunc)
    75987688  (x862-make-closure seg afunc nil)
    7599   (when vreg (<- x8664::arg_z))
     7689  (when vreg (<- *x862-arg-z*))
    76007690  (^))
    76017691
     
    76917781            (x862-form
    76927782             seg
    7693              (if need-break (if dest-vd x8664::arg_z) dest-vd)
     7783             (if need-break (if dest-vd *x862-arg-z*) dest-vd)
    76947784             (if need-break nil dest-cd)
    76957785             value)
    76967786            (when need-break
    76977787              (x862-unwind-set seg dest-cd dest-stack)
    7698               (when dest-vd (x862-copy-register seg dest-vd x8664::arg_z))
     7788              (when dest-vd (x862-copy-register seg dest-vd *x862-arg-z*))
    76997789              (x862-branch seg dest-cd))))))
    77007790    (x862-unreachable-store)))
     
    77167806           (ensuring-node-target (target vreg)
    77177807             (! lisp-word-ref-c target
    7718                 (x862-one-untargeted-reg-form seg base x8664::arg_z)
     7808                (x862-one-untargeted-reg-form seg base *x862-arg-z*)
    77197809                (ash fixoffset *x862-target-fixnum-shift*)))
    77207810           (^))
    77217811          (t (multiple-value-bind (breg oreg)
    7722                                   (x862-two-untargeted-reg-forms seg base x8664::arg_y offset x8664::arg_z)
     7812                                  (x862-two-untargeted-reg-forms seg base *x862-arg-y* offset *x862-arg-z*)
    77237813               (ensuring-node-target (target vreg)
    77247814                 (! lisp-word-ref target breg oreg))
     
    77337823           (ensuring-node-target (target vreg)
    77347824             (! lisp-word-ref-c target
    7735                 (x862-one-untargeted-reg-form seg base x8664::arg_z)
     7825                (x862-one-untargeted-reg-form seg base *x862-arg-z*)
    77367826                fixoffset))
    77377827           (^))
    77387828          (t (multiple-value-bind (breg oreg)
    7739                                   (x862-two-untargeted-reg-forms seg base x8664::arg_y offset x8664::arg_z)
     7829                                  (x862-two-untargeted-reg-forms seg base *x862-arg-y* offset *x862-arg-z*)
    77407830               (with-imm-target () (otemp :s32)
    77417831                 (! fixnum->signed-natural otemp oreg)
     
    77527842           (with-imm-target () (val :natural)
    77537843             (! lisp-word-ref-c val
    7754                 (x862-one-untargeted-reg-form seg base x8664::arg_z)
     7844                (x862-one-untargeted-reg-form seg base *x862-arg-z*)
    77557845                fixoffset)
    77567846             (<- val))
    77577847           (^))
    77587848          (t (multiple-value-bind (breg oreg)
    7759                  (x862-two-untargeted-reg-forms seg base x8664::arg_y offset x8664::arg_z)
     7849                 (x862-two-untargeted-reg-forms seg base *x862-arg-y* offset *x862-arg-z*)
    77607850               (with-imm-target () (otemp :s32)
    77617851                 (! fixnum->signed-natural otemp oreg)
     
    77677857(defx862 x862-int>0-p int>0-p (seg vreg xfer cc form)
    77687858  (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    7769     (x862-one-targeted-reg-form seg form ($ x8664::arg_z))
     7859    (x862-one-targeted-reg-form seg form ($ *x862-arg-z*))
    77707860    (! integer-sign)
    77717861    (x862-test-reg-%izerop seg vreg xfer x8664::imm0 cr-bit true-p 0)))
     
    77767866  (let* ((*x862-vstack* *x862-vstack*)
    77777867         (*x862-top-vstack-lcell* *x862-top-vstack-lcell*))
    7778     (x862-vpush-register seg (x862-one-untargeted-reg-form seg tag x8664::arg_z))
     7868    (x862-vpush-register seg (x862-one-untargeted-reg-form seg tag *x862-arg-z*))
    77797869    (if (x862-trivial-p valform)
    77807870      (progn
    7781         (x862-vpush-register seg (x862-one-untargeted-reg-form seg valform x8664::arg_z))
     7871        (x862-vpush-register seg (x862-one-untargeted-reg-form seg valform *x862-arg-z*))
    77827872        (x862-set-nargs seg 1))
    77837873      (x862-multiple-value-body seg valform))
     
    77957885         (tag-label-value (aref *backend-labels* tag-label))
    77967886         (mv-pass (x862-mv-p xfer)))
    7797     (x862-one-targeted-reg-form seg tag ($ x8664::arg_z))
     7887    (x862-one-targeted-reg-form seg tag ($ *x862-arg-z*))
    77987888    (if mv-pass
    77997889      (! nmkcatchmv tag-label-value)
     
    78027892    (if mv-pass
    78037893      (x862-multiple-value-body seg valform) 
    7804       (x862-one-targeted-reg-form seg valform ($ x8664::arg_z)))
     7894      (x862-one-targeted-reg-form seg valform ($ *x862-arg-z*)))
    78057895    (x862-lri seg x8664::imm0 (ash 1 *x862-target-fixnum-shift*))
    78067896    (if mv-pass
     
    78097899    (x862-close-undo)
    78107900    (@= tag-label)
    7811     (unless mv-pass (if vreg (<- x8664::arg_z)))
     7901    (unless mv-pass (if vreg (<- *x862-arg-z*)))
    78127902    (let* ((*x862-returning-values* mv-pass)) ; nlexit keeps values on stack
    78137903      (^))))
     
    78627952           (x862-three-targeted-reg-forms seg
    78637953                                          arr ($ x8664::arg_x)
    7864                                           i ($ x8664::arg_y)
    7865                                           j ($ x8664::arg_z))
     7954                                          i ($ *x862-arg-y*)
     7955                                          j ($ *x862-arg-z*))
    78667956           (x862-fixed-call-builtin seg vreg xfer nil (subprim-name->offset '.SParef2))))))
    78677957
     
    79188008                                         arr ($ x8664::temp0)
    79198009                                         i ($ x8664::arg_x)
    7920                                          j ($ x8664::arg_y)
    7921                                          k ($ x8664::arg_z))
     8010                                         j ($ *x862-arg-y*)
     8011                                         k ($ *x862-arg-z*))
    79228012           (x862-fixed-call-builtin seg vreg xfer nil (subprim-name->offset '.SParef3))))))
    79238013                                         
     
    79558045                                         arr ($ x8664::temp0)
    79568046                                         i ($ x8664::arg_x)
    7957                                          j ($ x8664::arg_y)
    7958                                          new ($ x8664::arg_z))
     8047                                         j ($ *x862-arg-y*)
     8048                                         new ($ *x862-arg-z*))
    79598049           (x862-fixed-call-builtin seg vreg xfer nil (subprim-name->offset '.SPaset2))))))
    79608050
     
    79928082                         (if (typep dim2 'fixnum) dim2))))
    79938083          (t
    7994            (x862-push-register seg (x862-one-untargeted-reg-form seg arr ($ x8664::arg_z)))
     8084           (x862-push-register seg (x862-one-untargeted-reg-form seg arr ($ *x862-arg-z*)))
    79958085           (x862-four-targeted-reg-forms seg
    79968086                                         i ($ x8664::temp0)
    79978087                                         j ($ x8664::arg_x)
    7998                                          k ($ x8664::arg_y)
    7999                                          new ($ x8664::arg_z))
     8088                                         k ($ *x862-arg-y*)
     8089                                         new ($ *x862-arg-z*))
    80008090           (x862-pop-register seg ($ x8664::temp1))
    80018091           (x862-fixed-call-builtin seg vreg xfer nil (subprim-name->offset '.SPaset3))))))
     
    80298119      (x862-vref seg vreg xfer type-keyword uvector index (unless *x862-reckless* (nx-lookup-target-uvector-subtag type-keyword)))
    80308120      (progn
    8031         (x862-three-targeted-reg-forms seg subtag ($ x8664::arg_x) uvector ($ x8664::arg_y) index ($ x8664::arg_z))
     8121        (x862-three-targeted-reg-forms seg subtag ($ x8664::arg_x) uvector ($ *x862-arg-y*) index ($ *x862-arg-z*))
    80328122        (! subtag-misc-ref)
    8033         (when vreg (<- ($ x8664::arg_z)))
     8123        (when vreg (<- ($ *x862-arg-z*)))
    80348124        (^)) )))
    80358125
     
    80438133      (x862-vset seg vreg xfer type-keyword uvector index newval (unless *x862-reckless* (nx-lookup-target-uvector-subtag type-keyword)))
    80448134      (progn
    8045         (x862-four-targeted-reg-forms seg subtag ($ x8664::temp0) uvector ($ x8664::arg_x) index ($ x8664::arg_y) newval ($ x8664::arg_z))
     8135        (x862-four-targeted-reg-forms seg subtag ($ x8664::temp0) uvector ($ x8664::arg_x) index ($ *x862-arg-y*) newval ($ *x862-arg-z*))
    80468136        (! subtag-misc-set)
    8047         (when vreg (<- ($ x8664::arg_z)))
     8137        (when vreg (<- ($ *x862-arg-z*)))
    80488138        (^)))))
    80498139
     
    80888178  (when vreg
    80898179    (let* ((symreg (x862-one-untargeted-reg-form seg (make-acode (%nx1-operator immediate)
    8090                                                                  (x862-symbol-entry-locative sym)) x8664::arg_z)))
     8180                                                                 (x862-symbol-entry-locative sym)) *x862-arg-z*)))
    80918181      (with-node-temps (vreg symreg) (val)
    80928182        (! symbol-function val symreg)
     
    81428232              (x862-open-undo $undostkblk))
    81438233            (! list))
    8144           (x862-vpush-register seg x8664::arg_z))
     8234          (x862-vpush-register seg *x862-arg-z*))
    81458235        (when rest (x862-bind-var seg rest restloc))
    81468236        (destructuring-bind (vars inits) auxen
     
    81648254                         seg
    81658255                         val
    8166                          (if (eq vreg x8664::arg_z) x8664::arg_y x8664::arg_z))))
     8256                         (if (eq vreg *x862-arg-z*) *x862-arg-y* *x862-arg-z*))))
    81678257          (! ,vinsn val-reg)
    81688258          (when vreg (<- val-reg))
     
    81878277
    81888278(defx862 x862-%badarg2 %badarg2 (seg vreg xfer badthing goodthing)
    8189   (x862-two-targeted-reg-forms seg badthing ($ x8664::arg_y) goodthing ($ x8664::arg_z))
     8279  (x862-two-targeted-reg-forms seg badthing ($ *x862-arg-y*) goodthing ($ *x862-arg-z*))
    81908280  (x862-lri seg ($ x8664::arg_x) (ash $XWRONGTYPE *x862-target-fixnum-shift*))
    81918281  (x862-set-nargs seg 3)
     
    82198309
    82208310(defx862 x862-setq-free setq-free (seg vreg xfer sym val)
    8221   (let* ((rsym ($ x8664::arg_y))
    8222          (rval ($ x8664::arg_z)))
     8311  (let* ((rsym ($ *x862-arg-y*))
     8312         (rval ($ *x862-arg-z*)))
    82238313    (x862-one-targeted-reg-form seg val rval)
    82248314    (x862-immediate seg rsym nil (x862-symbol-value-cell sym))
     
    82288318
    82298319(defx862 x862-%setf-macptr %setf-macptr (seg vreg xfer x y)
    8230   (x862-vpush-register seg (x862-one-untargeted-reg-form seg x x8664::arg_z))
     8320  (x862-vpush-register seg (x862-one-untargeted-reg-form seg x *x862-arg-z*))
    82318321  (with-imm-target () (src-reg :address)
    82328322    (x862-one-targeted-reg-form seg y src-reg)
    8233     (x862-vpop-register seg x8664::arg_z)
     8323    (x862-vpop-register seg *x862-arg-z*)
    82348324    (unless (or *x862-reckless* (x862-form-typep x 'macptr))
    82358325      (with-imm-temps (src-reg) ()
    8236         (! trap-unless-macptr x8664::arg_z)))
    8237     (! set-macptr-address src-reg x8664::arg_z)
    8238     (<- x8664::arg_z)
     8326        (! trap-unless-macptr *x862-arg-z*)))
     8327    (! set-macptr-address src-reg *x862-arg-z*)
     8328    (<- *x862-arg-z*)
    82398329    (^)))
    82408330
    82418331(defx862 x862-%setf-double-float %setf-double-float (seg vref xfer fnode fval)
    8242   (x862-vpush-register seg (x862-one-untargeted-reg-form seg fnode x8664::arg_z))
     8332  (x862-vpush-register seg (x862-one-untargeted-reg-form seg fnode *x862-arg-z*))
    82438333  (let* ((target ($ x8664::fp1 :class :fpr :mode :double-float))
    8244          (node ($ x8664::arg_z)))
     8334         (node ($ *x862-arg-z*)))
    82458335    (x862-one-targeted-reg-form seg fval target)
    82468336    (x862-vpop-register seg node)
     
    82888378         (protform-label (backend-get-next-label))
    82898379         (old-stack (x862-encode-stack)))
    8290     (x862-two-targeted-reg-forms seg symbols ($ x8664::arg_y) values ($ x8664::arg_z))
     8380    (x862-two-targeted-reg-forms seg symbols ($ *x862-arg-y*) values ($ *x862-arg-z*))
    82918381    (! progvsave)
    82928382    (x862-open-undo $undostkblk)
     
    83448434                (x862-form seg vreg nil newval)))
    83458435            (with-imm-target () (src :address)
    8346               (x862-two-targeted-reg-forms seg ptr src newval ($ x8664::arg_z))
    8347               (! mem-set-c-bit-variable-value src offval ($ x8664::arg_z))
    8348               (<- ($ x8664::arg_z)))))
     8436              (x862-two-targeted-reg-forms seg ptr src newval ($ *x862-arg-z*))
     8437              (! mem-set-c-bit-variable-value src offval ($ *x862-arg-z*))
     8438              (<- ($ *x862-arg-z*)))))
    83498439        (if constval
    83508440          (with-imm-target () (src :address)
    8351             (x862-two-targeted-reg-forms seg ptr src offset ($ x8664::arg_z))
     8441            (x862-two-targeted-reg-forms seg ptr src offset ($ *x862-arg-z*))
    83528442            (if (eql constval 0)
    8353               (! mem-set-bit-0 src ($ x8664::arg_z))
    8354               (! mem-set-bit-1 src ($ x8664::arg_z)))
     8443              (! mem-set-bit-0 src ($ *x862-arg-z*))
     8444              (! mem-set-bit-1 src ($ *x862-arg-z*)))
    83558445            (when vreg
    83568446              (x862-form seg vreg nil newval)))
    83578447          (with-imm-target () (src :address)
    8358             (x862-three-targeted-reg-forms seg ptr src offset ($ x8664::arg_y) newval ($ x8664::arg_z))
    8359             (! mem-set-bit-variable-value src ($ x8664::arg_y) ($ x8664::arg_z))
    8360             (<- ($ x8664::arg_z)))))
     8448            (x862-three-targeted-reg-forms seg ptr src offset ($ *x862-arg-y*) newval ($ *x862-arg-z*))
     8449            (! mem-set-bit-variable-value src ($ *x862-arg-y*) ($ *x862-arg-z*))
     8450            (<- ($ *x862-arg-z*)))))
    83618451      (^)))
    83628452
     
    83808470              (unless triv-by
    83818471                (x862-push-register seg ptr-reg))
    8382               (let* ((boxed-by (x862-one-targeted-reg-form seg by x8664::arg_z)))
     8472              (let* ((boxed-by (x862-one-targeted-reg-form seg by *x862-arg-z*)))
    83838473                (unless triv-by
    83848474                  (x862-pop-register seg ptr-reg))
     
    84218511      (setq ngpr-args 0)
    84228512      (unless simple-foreign-args
    8423         (x862-vpush-register seg (x862-one-untargeted-reg-form seg idx x8664::arg_z)))
     8513        (x862-vpush-register seg (x862-one-untargeted-reg-form seg idx *x862-arg-z*)))
    84248514      ;; Evaluate each form into the C frame, according to the
    84258515      ;; matching argspec.
     
    84558545                         (incf other-offset)))))))))     
    84568546      (unless simple-foreign-args
    8457         (x862-vpop-register seg ($ x8664::arg_z)))
     8547        (x862-vpop-register seg ($ *x862-arg-z*)))
    84588548      (! syscall)
    84598549      (x862-close-undo)
     
    84638553               (ensuring-node-target (target vreg)
    84648554                 (! makeu64)
    8465                  (x862-copy-register seg target ($ x8664::arg_z))))
     8555                 (x862-copy-register seg target ($ *x862-arg-z*))))
    84668556              ((eq resultspec :signed-doubleword)
    84678557               (ensuring-node-target (target vreg)
    84688558                 (! makes64)
    8469                  (x862-copy-register seg target ($ x8664::arg_z))))
     8559                 (x862-copy-register seg target ($ *x862-arg-z*))))
    84708560              (t
    84718561               (case resultspec
     
    85378627      (setq ngpr-args 0 nfpr-args 0)
    85388628      (unless simple-foreign-args
    8539         (x862-vpush-register seg (x862-one-untargeted-reg-form seg address x8664::arg_z)))
     8629        (x862-vpush-register seg (x862-one-untargeted-reg-form seg address *x862-arg-z*)))
    85408630      ;; Evaluate each form into the C frame, according to the
    85418631      ;; matching argspec.  Remember type and arg offset of any FP
     
    85508640          (case spec
    85518641            (:registers
    8552              (let* ((reg (x862-one-untargeted-reg-form seg valform x8664::arg_z)))
     8642             (let* ((reg (x862-one-untargeted-reg-form seg valform *x862-arg-z*)))
    85538643               (unless *x862-reckless*
    85548644                 (! trap-unless-macptr reg))
     
    86198709            (! reload-single-c-arg ($ fpreg :class :fpr :mode :single-float) from))))
    86208710      (if return-registers
    8621         (x862-vpop-register seg ($ x8664::arg_y)))
     8711        (x862-vpop-register seg ($ *x862-arg-y*)))
    86228712      (if simple-foreign-args
    8623         (x862-one-targeted-reg-form seg address x8664::arg_z)
    8624         (x862-vpop-register seg ($ x8664::arg_z)))
     8713        (x862-one-targeted-reg-form seg address *x862-arg-z*)
     8714        (x862-vpop-register seg ($ *x862-arg-z*)))
    86258715      (x862-lri seg x8664::rax (min 8 nfpr-args))
    86268716      (if return-registers
     
    86388728                 (progn
    86398729                   (! makeu64)
    8640                    (<- ($ x8664::arg_z)))
     8730                   (<- ($ *x862-arg-z*)))
    86418731                 (<- ($  x8664::rax :class :gpr :mode :u64))))
    86428732              ((eq resultspec :signed-doubleword)
     
    86448734                 (progn
    86458735                   (! makes64)
    8646                    (<- ($ x8664::arg_z)))
     8736                   (<- ($ *x862-arg-z*)))
    86478737                 (<- ($  x8664::rax :class :gpr :mode :s64))))
    86488738              (t
     
    86788768
    86798769(defx862 x862-%debug-trap %debug-trap (seg vreg xfer arg)
    8680   (x862-one-targeted-reg-form seg arg ($ x8664::arg_z))
     8770  (x862-one-targeted-reg-form seg arg ($ *x862-arg-z*))
    86818771  (! %debug-trap)
    8682   (<- ($ x8664::arg_z))
     8772  (<- ($ *x862-arg-z*))
    86838773  (^))
    86848774
     
    86868776  (seg vreg xfer arg)
    86878777  (ensuring-node-target (target vreg)
    8688     (let* ((reg (if (eq (hard-regspec-value target) x8664::arg_z) ($ x8664::arg_y) ($ x8664::arg_z))))
     8778    (let* ((reg (if (eq (hard-regspec-value target) *x862-arg-z*) ($ *x862-arg-y*) ($ *x862-arg-z*))))
    86898779      (x862-one-targeted-reg-form seg arg reg)
    86908780      (! eep.address target reg)))
     
    88558945         (x862-restore-nvrs seg *x862-register-restore-ea* *x862-register-restore-count*)
    88568946         (x862-restore-full-lisp-context seg)
    8857          (! %current-frame-ptr ($ x8664::arg_z))
     8947         (! %current-frame-ptr ($ *x862-arg-z*))
    88588948         (! jump-return-pc))
    88598949        (t
     
    88918981(defx862 x862-with-variable-c-frame with-variable-c-frame (seg vreg xfer size body &aux
    88928982                                                               (old-stack (x862-encode-stack)))
    8893   (let* ((reg (x862-one-untargeted-reg-form seg size x8664::arg_z)))
     8983  (let* ((reg (x862-one-untargeted-reg-form seg size *x862-arg-z*)))
    88948984    (! alloc-variable-c-frame reg)
    88958985    (x862-open-undo $undo-x86-c-frame)
     
    88978987
    88988988(defx862 x862-%symbol->symptr %symbol->symptr (seg vreg xfer sym)
    8899   (let* ((src (x862-one-untargeted-reg-form seg sym x8664::arg_z)))
     8989  (let* ((src (x862-one-untargeted-reg-form seg sym *x862-arg-z*)))
    89008990    (ensuring-node-target (target vreg)
    89018991      (! %symbol->symptr target src))
     
    89609050(defx862 x862-%fixnum-to-single %fixnum-to-single (seg vreg xfer arg)
    89619051  (with-fp-target () (sreg :single-float)
    8962     (let* ((r (x862-one-untargeted-reg-form seg arg x8664::arg_z)))
     9052    (let* ((r (x862-one-untargeted-reg-form seg arg *x862-arg-z*)))
    89639053      (unless (or (acode-fixnum-form-p arg)
    89649054                  *x862-reckless*)
     
    89709060(defx862 x862-%fixnum-to-double %fixnum-to-double (seg vreg xfer arg)
    89719061  (with-fp-target () (dreg :double-float)
    8972     (let* ((r (x862-one-untargeted-reg-form seg arg x8664::arg_z)))
     9062    (let* ((r (x862-one-untargeted-reg-form seg arg *x862-arg-z*)))
    89739063      (unless (or (acode-fixnum-form-p arg)
    89749064                  *x862-reckless*)
     
    90569146#-x86-target
    90579147(defun x8664-xcompile-lambda (def &key show-vinsns (symbolic-names t)
    9058                                   (target :linuxx8664)
     9148                                  (target :darwinx8664)
    90599149                                  (disassemble t))
    90609150  (let* ((*x862-debug-mask* (if show-vinsns
     
    90819171      xlfun)))
    90829172
    9083 
    9084 
    9085 
     9173#-x8632-target
     9174(defun x8632-xcompile-lambda (def &key show-vinsns (symbolic-names t)
     9175                                  (target :darwinx8632)
     9176                                  (disassemble t))
     9177  (let* ((*x862-debug-mask* (if show-vinsns
     9178                              (ash 1 x862-debug-vinsns-bit)
     9179                              0))
     9180         (backend (find-backend target))
     9181         (*target-ftd* (if backend
     9182                         (backend-target-foreign-type-data backend)
     9183                         *target-ftd*)))
     9184    (multiple-value-bind (xlfun warnings)
     9185        (compile-named-function def nil
     9186                                nil
     9187                                nil
     9188                                nil
     9189                                nil
     9190                                nil
     9191                                target)
     9192      (signal-or-defer-warnings warnings nil)
     9193      (when disassemble
     9194        (format t "~%~%")
     9195        (apply #'x8632-disassemble-xfunction
     9196               xlfun
     9197               (unless symbolic-names (list nil))))
     9198      xlfun)))
     9199
     9200
     9201
     9202
Note: See TracChangeset for help on using the changeset viewer.