Changeset 10174


Ignore:
Timestamp:
Jul 21, 2008, 7:15:37 PM (11 years ago)
Author:
rme
Message:

Use *x862-arg-z*, *x862-arg-y*, etc. instead of the x8664::arg_z,
etc. constants.

Bind those special variables appropriately in x862-compile.

This doesn't add any x8632 stuff, but it should make the diffs from
future commits a bit smaller, I hope.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/compiler/X86/x862.lisp

    r10079 r10174  
    178178(defvar *x862-result-reg* x8664::arg_z)
    179179
     180(defvar *x862-arg-z* nil)
     181(defvar *x862-arg-y* nil)
     182(defvar *x862-imm0* nil)
     183(defvar *x862-temp0* nil)
     184(defvar *x862-temp1* nil)
     185(defvar *x862-fn* nil)
     186(defvar *x862-fname* nil)
     187(defvar *x862-ra0* nil)
     188
     189(defvar *x862-allocptr* nil)
     190
     191(defvar *x862-fp0* nil)
     192(defvar *x862-fp1* nil)
    180193
    181194(declaim (fixnum *x862-vstack* *x862-cstack*))
     
    296309            (x862-copy-register seg ea valreg))
    297310          ((addrspec-vcell-p ea)     ; closed-over vcell
    298            (x862-copy-register seg x8664::arg_z valreg)
     311           (x862-copy-register seg *x862-arg-z* valreg)
    299312           (x862-stack-to-register seg ea x8664::arg_x)
    300            (x862-lri seg x8664::arg_y 0)
    301            (! call-subprim-3 x8664::arg_z (subprim-name->offset '.SPgvset) x8664::arg_x x8664::arg_y x8664::arg_z))
     313           (x862-lri seg *x862-arg-y* 0)
     314           (! call-subprim-3 *x862-arg-z* (subprim-name->offset '.SPgvset) x8664::arg_x *x862-arg-y* *x862-arg-z*))
    302315          ((memory-spec-p ea)    ; vstack slot
    303316           (x862-register-to-stack seg valreg ea))
     
    316329                      (the fixnum (nx-var-bits var))))
    317330      (let* ((ea (var-ea var))
    318              (arg ($ x8664::arg_z))
    319              (result ($ x8664::arg_z)))
     331             (arg ($ *x862-arg-z*))
     332             (result ($ *x862-arg-z*)))
    320333        (x862-do-lexical-reference seg arg ea)
    321334        (x862-set-nargs seg 1)
    322         (! ref-constant ($ x8664::fname) (x86-immediate-label (x862-symbol-entry-locative '%cons-magic-next-method-arg)))
     335        (! ref-constant ($ *x862-fname*) (x86-immediate-label (x862-symbol-entry-locative '%cons-magic-next-method-arg)))
    323336        (! call-known-symbol arg)
    324337        (x862-do-lexical-setq seg nil ea result)))))
     
    426439  (if (zerop count)
    427440    0
    428     (min (- (ash ea (- x8664::word-shift)) count) #xff)))
     441    (min (- (ash ea (- *x862-target-node-shift*)) count) #xff)))
    429442
    430443
     
    453466           (*x862-vstack* 0)
    454467           (*x862-cstack* 0)
    455            (*x862-target-num-arg-regs* (target-arch-case (:x8664  $numx8664argregs)))
    456            (*x862-target-num-save-regs* (target-arch-case (:x8664  $numx8664saveregs)))
     468           (*x86-lap-entry-offset* x8664::fulltag-function)
     469           (*x862-result-reg* x8664::arg_z)
     470           (*x862-imm0* x8664::imm0)
     471           (*x862-arg-z* x8664::arg_z)
     472           (*x862-arg-y* x8664::arg_y)
     473           (*x862-temp0* x8664::temp0)
     474           (*x862-temp1* x8664::temp1)
     475           (*x862-fn* x8664::fn)
     476           (*x862-fname* x8664::fname)
     477           (*x862-ra0* x8664::ra0)
     478           (*x862-allocptr* x8664::allocptr)
     479           (*x862-fp0* x8664::fp0)
     480           (*x862-fp1* x8664::fp1)
     481           (*x862-target-num-arg-regs* $numx8664argregs)
     482           (*x862-target-num-save-regs* $numx8664saveregs)
    457483           (*x862-target-lcell-size* (arch::target-lisp-node-size (backend-target-arch *target-backend*)))
    458484           (*x862-target-fixnum-shift* (arch::target-fixnum-shift (backend-target-arch *target-backend*)))
     
    469495           (*x862-var-cells* nil)
    470496           (*backend-vinsns* (backend-p2-vinsn-templates *target-backend*))
    471            (*backend-node-regs* (target-arch-case (:x8664 x8664-node-regs)))
    472            (*backend-node-temps* (target-arch-case (:x8664 x8664-temp-node-regs)))
    473            (*available-backend-node-temps* (target-arch-case (:x8664 x8664-temp-node-regs)))
    474            (*backend-imm-temps* (target-arch-case (:x8664 x8664-imm-regs)))
    475            (*available-backend-imm-temps* (target-arch-case (:x8664 x8664-imm-regs)))
    476            (*backend-crf-temps* (target-arch-case (:x8664 x8664-cr-fields)))
    477            (*available-backend-crf-temps* (target-arch-case (:x8664 x8664-cr-fields)))
    478            (*backend-fp-temps* (target-arch-case (:x8664 x8664-temp-fp-regs)))
    479            (*available-backend-fp-temps* (target-arch-case (:x8664 x8664-temp-fp-regs)))
     497           (*backend-node-regs* x8664-node-regs)
     498           (*backend-node-temps* x8664-temp-node-regs)
     499           (*available-backend-node-temps* x8664-temp-node-regs)
     500           (*backend-imm-temps* x8664-imm-regs)
     501           (*available-backend-imm-temps* x8664-imm-regs)
     502           (*backend-crf-temps* x8664-cr-fields)
     503           (*available-backend-crf-temps* x8664-cr-fields)
     504           (*backend-fp-temps* x8664-temp-fp-regs)
     505           (*available-backend-fp-temps* x8664-temp-fp-regs)
    480506           (bits 0)
    481507           (*logical-register-counter* -1)
     
    873899        (if (setq reg (x862-assign-register-var rest))
    874900          (progn
    875             (x862-copy-register seg reg x8664::arg_z)
     901            (x862-copy-register seg reg *x862-arg-z*)
    876902            (x862-set-var-ea seg rest reg))
    877903            (let* ((loc *x862-vstack*))
    878               (x862-vpush-register seg x8664::arg_z :reserved)
     904              (x862-vpush-register seg *x862-arg-z* :reserved)
    879905              (x862-note-top-cell rest)
    880906              (x862-bind-var seg rest loc *x862-top-vstack-lcell*))))
     
    903929            (if reg
    904930              (x862-form seg reg regloadedlabel initform)
    905               (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ x8664::arg_z)) (x862-vloc-ea vloc)))
     931              (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ *x862-arg-z*)) (x862-vloc-ea vloc)))
    906932            (@ skipinitlabel)))
    907933        (if reg
     
    934960            (if reg
    935961              (x862-form seg reg regloadedlabel initform)
    936               (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ x8664::arg_z)) (x862-vloc-ea vloc)))
     962              (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ *x862-arg-z*)) (x862-vloc-ea vloc)))
    937963            (@ skipinitlabel)))
    938964        (if reg
     
    9841010            (push (x862-vpush-arg-register seg ($ x8664::arg_x) xvar) reg-vars))
    9851011          (if (>= nargs 2)
    986             (push (x862-vpush-arg-register seg ($ x8664::arg_y) yvar) reg-vars))
     1012            (push (x862-vpush-arg-register seg ($ *x862-arg-y*) yvar) reg-vars))
    9871013          (if (>= nargs 1)
    988             (push (x862-vpush-arg-register seg ($ x8664::arg_z) zvar) reg-vars))))
     1014            (push (x862-vpush-arg-register seg ($ *x862-arg-z*) zvar) reg-vars))))
    9891015      reg-vars)))
    9901016
     
    10141040      (if (> min $numx8664argregs)
    10151041        (! save-lisp-context-in-frame)
    1016         (if (<= max $numx8664argregs)
     1042        (if (<= max *x862-target-num-arg-regs*)
    10171043          (! save-lisp-context-no-stack-args)
    10181044          (! save-lisp-context-variable-arg-count)))
     
    10511077            (with-crf-target () crf
    10521078              (x862-compare-ea-to-nil seg crf (x862-make-compound-cd 0 skipinitlabel) (x862-vloc-ea spvloc) x86::x86-e-bits t))
    1053             (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ x8664::arg_z)) (x862-vloc-ea vloc))
     1079            (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ *x862-arg-z*)) (x862-vloc-ea vloc))
    10541080            (@ skipinitlabel)))
    10551081        (x862-bind-structured-var seg var vloc var-lcell context)
     
    10681094             (sploc (%i+ vloc *x862-target-node-size*))
    10691095             (var-lcell (pop lcells))
    1070              (sp-reg ($ x8664::arg_z))
     1096             (sp-reg ($ *x862-arg-z*))
    10711097             (sp-lcell (pop lcells)))
    10721098        (unless (nx-null initform)
     
    10751101            (with-crf-target () crf
    10761102              (x862-compare-register-to-nil seg crf (x862-make-compound-cd 0 skipinitlabel) sp-reg x86::x86-e-bits t))
    1077             (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ x8664::arg_z)) (x862-vloc-ea vloc))
     1103            (x862-register-to-stack seg (x862-one-untargeted-reg-form seg initform ($ *x862-arg-z*)) (x862-vloc-ea vloc))
    10781104            (@ skipinitlabel)))
    10791105        (x862-bind-structured-var seg var vloc var-lcell context)
     
    12071233(defun x862-mvpass (seg form &optional xfer)
    12081234  (with-x86-local-vinsn-macros (seg)
    1209     (x862-form seg  ($ x8664::arg_z) (logior (or xfer 0) $backend-mvpass-mask) form)))
     1235    (x862-form seg  ($ *x862-arg-z*) (logior (or xfer 0) $backend-mvpass-mask) form)))
    12101236
    12111237(defun x862-adjust-vstack (delta)
     
    13241350                (x862-store-immediate seg form target)))))
    13251351        (if (and (listp form) *load-time-eval-token* (eq (car form) *load-time-eval-token*))
    1326           (x862-store-immediate seg form ($ x8664::temp0))))
     1352          (x862-store-immediate seg form ($ *x862-temp0*))))
    13271353      (^))))
    13281354
     
    13821408         (:x8664 t))
    13831409      (! box-fixnum node-dest s32-src)
    1384       (let* ((arg_z ($ x8664::arg_z))
    1385              (imm0 ($ x8664::imm0 :mode :s32)))
     1410      (let* ((arg_z ($ *x862-arg-z*))
     1411             (imm0 ($ *x862-imm0* :mode :s32)))
    13861412        (x862-copy-register seg imm0 s32-src)
    13871413        (! call-subprim (subprim-name->offset '.SPmakes32))
     
    13991425        (! set-bigits-after-fixnum-overflow node-dest)
    14001426        (@ no-overflow))
    1401       (let* ((arg_z ($ x8664::arg_z))
    1402              (imm0 (make-wired-lreg x8664::imm0 :mode (get-regspec-mode s64-src))))
     1427      (let* ((arg_z ($ *x862-arg-z*))
     1428             (imm0 (make-wired-lreg *x862-imm0* :mode (get-regspec-mode s64-src))))
    14031429        (x862-copy-register seg imm0 s64-src)
    14041430        (! call-subprim (subprim-name->offset '.SPmakes64))
     
    14111437         (:x8664 t))
    14121438      (! box-fixnum node-dest u32-src)
    1413       (let* ((arg_z ($ x8664::arg_z))
    1414              (imm0 ($ x8664::imm0 :mode :u32)))
     1439      (let* ((arg_z ($ *x862-arg-z*))
     1440             (imm0 ($ *x862-imm0* :mode :u32)))
    14151441        (x862-copy-register seg imm0 u32-src)
    14161442        (! call-subprim (subprim-name->offset '.SPmakeu32))
     
    14291455        (! set-bigits-after-fixnum-overflow node-dest)
    14301456        (@ no-overflow))
    1431       (let* ((arg_z ($ x8664::arg_z))
    1432              (imm0 ($ x8664::imm0 :mode :u64)))
     1457      (let* ((arg_z ($ *x862-arg-z*))
     1458             (imm0 ($ *x862-imm0* :mode :u64)))
    14331459        (x862-copy-register seg imm0 u64-src)
    14341460        (! call-subprim (subprim-name->offset '.SPmakeu64))
     
    16231649        (if (or safe (not index-known-fixnum))
    16241650          (multiple-value-setq (src unscaled-idx)
    1625             (x862-two-untargeted-reg-forms seg vector x8664::arg_y index x8664::arg_z))
    1626           (setq src (x862-one-untargeted-reg-form seg vector x8664::arg_z)))
     1651            (x862-two-untargeted-reg-forms seg vector *x862-arg-y* index *x862-arg-z*))
     1652          (setq src (x862-one-untargeted-reg-form seg vector *x862-arg-z*)))
    16271653        (when safe
    16281654          (if (typep safe 'fixnum)
     
    16571683        (if constidx
    16581684          (multiple-value-setq (src val-reg)
    1659             (x862-two-targeted-reg-forms seg array ($ x8664::temp0) new val-reg))
     1685            (x862-two-targeted-reg-forms seg array ($ *x862-temp0*) new val-reg))
    16601686          (multiple-value-setq (src unscaled-i unscaled-j val-reg)
    16611687            (if needs-memoization
    16621688              (progn
    16631689                (x862-four-targeted-reg-forms seg
    1664                                               array ($ x8664::temp0)
     1690                                              array ($ *x862-temp0*)
    16651691                                              i ($ x8664::arg_x)
    1666                                               j ($ x8664::arg_y)
     1692                                              j ($ *x862-arg-y*)
    16671693                                              new val-reg)
    1668                 (values ($ x8664::temp0) ($ x8664::arg_x) ($ x8664::arg_y) ($ x8664::arg_z)))
     1694                (values ($ *x862-temp0*) ($ x8664::arg_x) ($ *x862-arg-y*) ($ *x862-arg-z*)))
    16691695              (x862-four-untargeted-reg-forms seg
    1670                                               array ($ x8664::temp0)
     1696                                              array ($ *x862-temp0*)
    16711697                                              i ($ x8664::arg_x)
    1672                                               j ($ x8664::arg_y)
     1698                                              j ($ *x862-arg-y*)
    16731699                                              new val-reg))))
    16741700        (let* ((*available-backend-imm-temps* *available-backend-imm-temps*))
     
    16891715              (! trap-unless-fixnum unscaled-j)))
    16901716          (with-imm-target () dim1
    1691             (let* ((idx-reg ($ x8664::arg_y)))
     1717            (let* ((idx-reg ($ *x862-arg-y*)))
    16921718              (if constidx
    16931719                (if needs-memoization
    1694                   (x862-lri seg x8664::arg_y (ash constidx *x862-target-fixnum-shift*)))
     1720                  (x862-lri seg *x862-arg-y* (ash constidx *x862-target-fixnum-shift*)))
    16951721                (progn
    16961722                  (if safe                 
     
    17341760          (progn
    17351761            (setq src ($ x8664::temp1)
    1736                   unscaled-i ($ x8664::temp0)
     1762                  unscaled-i ($ *x862-temp0*)
    17371763                  unscaled-j ($ x8664::arg_x)
    1738                   unscaled-k ($ x8664::arg_y))
     1764                  unscaled-k ($ *x862-arg-y*))
    17391765            (x862-push-register
    17401766             seg
    1741              (x862-one-untargeted-reg-form seg array ($ x8664::arg_z)))
     1767             (x862-one-untargeted-reg-form seg array ($ *x862-arg-z*)))
    17421768            (x862-four-targeted-reg-forms seg
    1743                                           i ($ x8664::temp0)
     1769                                          i ($ *x862-temp0*)
    17441770                                          j ($ x8664::arg_x)
    1745                                           k ($ x8664::arg_y)
     1771                                          k ($ *x862-arg-y*)
    17461772                                          new val-reg)
    17471773            (x862-pop-register seg src)))
     
    17671793          (with-imm-target () dim1
    17681794            (with-imm-target (dim1) dim2
    1769               (let* ((idx-reg ($ x8664::arg_y)))
     1795              (let* ((idx-reg ($ *x862-arg-y*)))
    17701796                (if constidx
    17711797                  (when needs-memoization
     
    17961822                 (+ (* i-known-fixnum dim1) j-known-fixnum))))
    17971823      (if constidx
    1798         (setq src (x862-one-targeted-reg-form seg array ($ x8664::arg_z)))
     1824        (setq src (x862-one-targeted-reg-form seg array ($ *x862-arg-z*)))
    17991825        (multiple-value-setq (src unscaled-i unscaled-j)
    18001826          (x862-three-untargeted-reg-forms seg
    18011827                                           array x8664::arg_x
    1802                                            i x8664::arg_y
    1803                                            j x8664::arg_z)))
     1828                                           i *x862-arg-y*
     1829                                           j *x862-arg-z*)))
    18041830      (when safe       
    18051831        (when (typep safe 'fixnum)
     
    18451871                    k-known-fixnum))))
    18461872      (if constidx
    1847         (setq src (x862-one-targeted-reg-form seg array ($ x8664::arg_z)))
     1873        (setq src (x862-one-targeted-reg-form seg array ($ *x862-arg-z*)))
    18481874        (multiple-value-setq (src unscaled-i unscaled-j unscaled-k)
    18491875          (x862-four-untargeted-reg-forms seg
    1850                                            array x8664::temp0
     1876                                           array *x862-temp0*
    18511877                                           i x8664::arg_x
    1852                                            j x8664::arg_y
    1853                                            k x8664::arg_z)))
     1878                                           j *x862-arg-y*
     1879                                           k *x862-arg-z*)))
    18541880      (when safe       
    18551881        (when (typep safe 'fixnum)
     
    18881914        (if (or safe (not index-known-fixnum))
    18891915          (multiple-value-setq (src unscaled-idx target)
    1890             (x862-three-untargeted-reg-forms seg vector x8664::arg_y index x8664::arg_z value (or vreg target)))
     1916            (x862-three-untargeted-reg-forms seg vector *x862-arg-y* index *x862-arg-z* value (or vreg target)))
    18911917          (multiple-value-setq (src target)
    1892             (x862-two-untargeted-reg-forms seg vector x8664::arg_y value (or vreg target))))
     1918            (x862-two-untargeted-reg-forms seg vector *x862-arg-y* value (or vreg target))))
    18931919        (when safe
    18941920          (with-imm-temps (target) ()   ; Don't use target in type/bounds check
     
    19641990         (next-imm-target (available-imm-temp  *available-backend-imm-temps*))
    19651991         (next-fp-target (available-fp-temp *available-backend-fp-temps*))
    1966          (acc (make-wired-lreg x8664::arg_z)))
     1992         (acc (make-wired-lreg *x862-arg-z*)))
    19671993    (cond ((or is-node
    19681994               (eq vreg :push)
     
    21652191      (cond ((and is-node node-value-needs-memoization)
    21662192             (unless (and (eql (hard-regspec-value src) x8664::arg_x)
    2167                           (eql (hard-regspec-value unscaled-idx) x8664::arg_y)
    2168                           (eql (hard-regspec-value val-reg) x8664::arg_z))
     2193                          (eql (hard-regspec-value unscaled-idx) *x862-arg-y*)
     2194                          (eql (hard-regspec-value val-reg) *x862-arg-z*))
    21692195               (compiler-bug "Bug: invalid register targeting for gvset: ~s" (list src unscaled-idx val-reg)))
    21702196             (! call-subprim-3 val-reg (subprim-name->offset '.SPgvset) src unscaled-idx val-reg))
     
    22852311           (index-known-fixnum (acode-fixnum-form-p index)))
    22862312      (let* ((src ($ x8664::arg_x))
    2287              (unscaled-idx ($ x8664::arg_y))
    2288              (result-reg ($ x8664::arg_z)))
     2313             (unscaled-idx ($ *x862-arg-y*))
     2314             (result-reg ($ *x862-arg-z*)))
    22892315        (cond (needs-memoization
    22902316               (x862-three-targeted-reg-forms seg
     
    24172443                                  (backend-get-next-label))))
    24182444          (unless simple-case
    2419             (x862-vpush-register seg (x862-one-untargeted-reg-form seg fn x8664::arg_z))
     2445            (x862-vpush-register seg (x862-one-untargeted-reg-form seg fn *x862-arg-z*))
    24202446            (setq fn (x862-vloc-ea vstack)))
    24212447          (x862-invoke-fn seg fn (x862-arglist seg arglist mv-return-label) spread-p xfer mv-return-label)
     
    24332459          (setq *x862-cstack* cstack)
    24342460          (when (or (logbitp $backend-mvpass-bit xfer) (not mv-p))
    2435             (<- x8664::arg_z)
     2461            (<- *x862-arg-z*)
    24362462            (x862-branch seg (logand (lognot $backend-mvpass-mask) xfer)))))
    24372463      nil)))
     
    24522478    (if jump-p
    24532479      (! jump-known-symbol)
    2454       (! call-known-symbol x8664::arg_z))))
     2480      (! call-known-symbol *x862-arg-z*))))
    24552481
    24562482;;; Nargs = nil -> multiple-value case.
     
    24712497           (expression-p (or (typep fn 'lreg) (and (fixnump fn) (not label-p))))
    24722498           (callable (or symp lfunp label-p))
    2473            (destreg (if symp ($ x8664::fname) (unless label-p ($ x8664::temp0))))
     2499           (destreg (if symp ($ *x862-fname*) (unless label-p ($ *x862-temp0*))))
    24742500           (alternate-tail-call
    24752501            (and tail-p label-p *x862-tail-label* (eql nargs *x862-tail-nargs*) (not spread-p))))
     
    25102536              (unless mvpass-label (compiler-bug "no label for mvpass"))
    25112537              (if label-p
    2512                 (x862-copy-register seg call-reg ($ x8664::fn))
     2538                (x862-copy-register seg call-reg ($ *x862-fn*))
    25132539                (if a-reg
    25142540                  (x862-copy-register seg call-reg  a-reg)
     
    25492575                  (unless (or label-p a-reg) (x862-store-immediate seg func destreg))
    25502576                  (when label-p
    2551                     (x862-copy-register seg x8664::temp0 x8664::fn))
     2577                    (x862-copy-register seg *x862-temp0* *x862-fn*))
    25522578
    25532579                  (cond ((or spread-p (null nargs))
     
    26212647      (let* ((inherited-vars (afunc-inherited-vars afunc))
    26222648             (arch (backend-target-arch *target-backend*))
    2623              (dest ($ x8664::arg_z))
     2649             (dest ($ *x862-arg-z*))
    26242650             (vsize (+ (length inherited-vars)
    26252651                       5                ; %closure-code%, afunc
     
    26372663            (progn
    26382664              (x862-lri seg
    2639                         x8664::imm0
     2665                        *x862-imm0*
    26402666                        (arch::make-vheader vsize (nx-lookup-target-uvector-subtag :function)))
    26412667              (x862-lri seg x8664::imm1 (- (ash (logandc2 (+ vsize 2) 1) (arch::target-word-shift arch)) (target-arch-case  (:x8664 x8664::fulltag-misc))))
    26422668              (! %allocate-uvector dest)))
    2643           (! init-nclosure x8664::arg_z)
     2669          (! init-nclosure *x862-arg-z*)
    26442670          (x862-store-immediate seg (x862-afunc-lfun-ref afunc) x8664::ra0)
    2645           (with-node-temps (x8664::arg_z) (t0 t1 t2 t3)
     2671          (with-node-temps (*x862-arg-z*) (t0 t1 t2 t3)
    26462672            (do* ((func x8664::ra0 nil))
    26472673                 ((null inherited-vars))
     
    26512677                     (t3r (if inherited-vars (var-to-reg (pop inherited-vars) t3))))
    26522678                (setq cell (set-some-cells dest cell t0r t1r t2r t3r)))))
    2653           (x862-lri seg x8664::arg_y (ash (logior (ash 1 $lfbits-noname-bit) (ash 1 $lfbits-trampoline-bit)) *x862-target-fixnum-shift*))
    2654           (! misc-set-c-node x8664::arg_y dest cell))
     2679          (x862-lri seg *x862-arg-y* (ash (logior (ash 1 $lfbits-noname-bit) (ash 1 $lfbits-trampoline-bit)) *x862-target-fixnum-shift*))
     2680          (! misc-set-c-node *x862-arg-y* dest cell))
    26552681        (! finalize-closure dest)
    26562682        dest))))
     
    27312757              (x862-adjust-vstack *x862-target-node-size*))
    27322758             
    2733             (let* ((reg (x862-one-untargeted-reg-form seg arg x8664::arg_z)))
     2759            (let* ((reg (x862-one-untargeted-reg-form seg arg *x862-arg-z*)))
    27342760              (x862-vpush-register-arg seg reg)))
    27352761          (incf n)))
     
    27392765               (xform (%caddr revregargs)))
    27402766          (if (eq 3 nregs)
    2741             (x862-three-targeted-reg-forms seg xform ($ x8664::arg_x) yform ($ x8664::arg_y) zform ($ x8664::arg_z))
     2767            (x862-three-targeted-reg-forms seg xform ($ x8664::arg_x) yform ($ *x862-arg-y*) zform ($ *x862-arg-z*))
    27422768            (if (eq 2 nregs)
    2743               (x862-two-targeted-reg-forms seg yform ($ x8664::arg_y) zform ($ x8664::arg_z))
    2744               (x862-one-targeted-reg-form seg zform ($ x8664::arg_z))))))
     2769              (x862-two-targeted-reg-forms seg yform ($ *x862-arg-y*) zform ($ *x862-arg-z*))
     2770              (x862-one-targeted-reg-form seg zform ($ *x862-arg-z*))))))
    27452771      n)))
    27462772
     
    27842810            immreg)
    27852811          (progn
    2786             (x862-one-targeted-reg-form seg form (make-wired-lreg x8664::imm0 :mode modeval))))))))
     2812            (x862-one-targeted-reg-form seg form (make-wired-lreg *x862-imm0* :mode modeval))))))))
    27872813
    27882814
     
    28752901      (declare (fixnum class mode))
    28762902      (cond ((= class hard-reg-class-fpr)
    2877              (make-wired-lreg x8664::fp1 :class class :mode mode))
     2903             (make-wired-lreg *x862-fp1* :class class :mode mode))
    28782904            ((= class hard-reg-class-gpr)
    28792905             (if (= mode hard-reg-class-gpr-mode-node)
    2880                ($ x8664::arg_z)
     2906               ($ *x862-arg-z*)
    28812907               (make-wired-lreg x8664::imm0 :mode mode)))
    28822908            (t (compiler-bug "Unknown register class for reg ~s" reg))))))
     
    32463272      (if (and (eql u8-operator (%nx1-operator lisptag))
    32473273               (eql 0 u8constant))
    3248         (let* ((formreg (x862-one-untargeted-reg-form seg form x8664::arg_z)))
     3274        (let* ((formreg (x862-one-untargeted-reg-form seg form *x862-arg-z*)))
    32493275         
    32503276          (! set-flags-from-lisptag formreg))
     
    32843310          (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)
    32853311          (if (and boolean (or js32 is32))
    3286             (let* ((reg (x862-one-untargeted-reg-form seg (if js32 i j) x8664::arg_z))
     3312            (let* ((reg (x862-one-untargeted-reg-form seg (if js32 i j) *x862-arg-z*))
    32873313                   (constant (or js32 is32)))
    32883314              (if (zerop constant)
     
    33043330                seg
    33053331                (if js32 i j)
    3306                 x8664::arg_z)
     3332                *x862-arg-z*)
    33073333               cr-bit
    33083334               true-p
    33093335               (or js32 is32)))
    3310               (multiple-value-bind (ireg jreg) (x862-two-untargeted-reg-forms seg i x8664::arg_y j x8664::arg_z)
     3336              (multiple-value-bind (ireg jreg) (x862-two-untargeted-reg-forms seg i *x862-arg-y* j *x862-arg-z*)
    33113337                (x862-compare-registers seg vreg xfer ireg jreg cr-bit true-p)))))))))
    33123338
     
    34913517
    34923518(defun x862-test-%izerop (seg vreg xfer form cr-bit true-p)
    3493   (x862-test-reg-%izerop seg vreg xfer (x862-one-untargeted-reg-form seg form x8664::arg_z) cr-bit true-p 0))
     3519  (x862-test-reg-%izerop seg vreg xfer (x862-one-untargeted-reg-form seg form *x862-arg-z*) cr-bit true-p 0))
    34943520
    34953521(defun x862-test-reg-%izerop (seg vreg xfer reg cr-bit true-p  zero)
     
    38063832                 (x862-open-undo $undostkblk curstack)
    38073833                 (! stack-cons-list))
    3808                (setq val x8664::arg_z))
     3834               (setq val *x862-arg-z*))
    38093835              ((eq op (%nx1-operator list*))
    38103836               (let* ((arglist (%cadr val)))                   
     
    38163842                   (! stack-cons-list*)
    38173843                   (x862-open-undo $undostkblk curstack))
    3818                  (setq val x8664::arg_z)))
     3844                 (setq val *x862-arg-z*)))
    38193845              ((eq op (%nx1-operator multiple-value-list))
    38203846               (x862-multiple-value-body seg (%cadr val))
    38213847               (x862-open-undo $undostkblk curstack)
    38223848               (! stack-cons-list)
    3823                (setq val x8664::arg_z))
     3849               (setq val *x862-arg-z*))
    38243850              ((eq op (%nx1-operator cons))
    3825                (let* ((y ($ x8664::arg_y))
    3826                       (z ($ x8664::arg_z))
    3827                       (result ($ x8664::arg_z)))
     3851               (let* ((y ($ *x862-arg-y*))
     3852                      (z ($ *x862-arg-z*))
     3853                      (result ($ *x862-arg-z*)))
    38283854                 (x862-two-targeted-reg-forms seg (%cadr val) y (%caddr val) z)
    38293855                 (x862-open-undo $undostkblk )
     
    38413867                 (if (nx-constant-form-p clear-form)
    38423868                   (progn
    3843                      (x862-one-targeted-reg-form seg (%cadr val) ($ x8664::arg_z))
     3869                     (x862-one-targeted-reg-form seg (%cadr val) ($ *x862-arg-z*))
    38443870                     (if (nx-null clear-form)
    38453871                       (! make-stack-block)
     
    38483874                                    (let ((stack-block-0-label (backend-get-next-label))
    38493875                                          (done-label (backend-get-next-label))
    3850                                           (rval ($ x8664::arg_z))
    3851                                           (rclear ($ x8664::arg_y)))
     3876                                          (rval ($ *x862-arg-z*))
     3877                                          (rclear ($ *x862-arg-y*)))
    38523878                                      (x862-two-targeted-reg-forms seg (%cadr val) rval clear-form rclear)
    38533879                                      (! compare-to-nil crf rclear)
     
    38593885                                      (@ done-label)))))
    38603886               (x862-open-undo $undo-x86-c-frame)
    3861                (setq val ($ x8664::arg_z)))
     3887               (setq val ($ *x862-arg-z*)))
    38623888              ((eq op (%nx1-operator make-list))
    3863                (x862-two-targeted-reg-forms seg (%cadr val) ($ x8664::arg_y) (%caddr val) ($ x8664::arg_z))
     3889               (x862-two-targeted-reg-forms seg (%cadr val) ($ *x862-arg-y*) (%caddr val) ($ *x862-arg-z*))
    38643890               (x862-open-undo $undostkblk curstack)
    38653891               (! make-stack-list)
    3866                (setq val x8664::arg_z))       
     3892               (setq val *x862-arg-z*))       
    38673893              ((eq (%car val) (%nx1-operator vector))
    38683894               (let* ((*x862-vstack* *x862-vstack*)
     
    38713897                 (! make-stack-vector))
    38723898               (x862-open-undo $undostkblk)
    3873                (setq val x8664::arg_z))
     3899               (setq val *x862-arg-z*))
    38743900              ((eq op (%nx1-operator %gvector))
    38753901               (let* ((*x862-vstack* *x862-vstack*)
     
    38793905                 (! make-stack-gvector))
    38803906               (x862-open-undo $undostkblk)
    3881                (setq val x8664::arg_z))
     3907               (setq val *x862-arg-z*))
    38823908              ((eq op (%nx1-operator closed-function))
    38833909               (setq val (x862-make-closure seg (cadr val) t))) ; can't error
     
    38903916                     (if init-p
    38913917                       (progn
    3892                          (x862-three-targeted-reg-forms seg element-count ($ x8664::arg_x) subtag ($ x8664::arg_y) init ($ x8664::arg_z))
     3918                         (x862-three-targeted-reg-forms seg element-count ($ x8664::arg_x) subtag ($ *x862-arg-y*) init ($ *x862-arg-z*))
    38933919                         (! stack-misc-alloc-init))
    38943920                       (progn
    3895                          (x862-two-targeted-reg-forms seg element-count ($ x8664::arg_y)  subtag ($ x8664::arg_z))
     3921                         (x862-two-targeted-reg-forms seg element-count ($ *x862-arg-y*)  subtag ($ *x862-arg-z*))
    38963922                         (! stack-misc-alloc)))
    38973923                     (if is-node
    38983924                       (x862-open-undo $undostkblk)
    38993925                       (x862-open-undo $undo-x86-c-frame))
    3900                      (setq val ($ x8664::arg_z))))))))))
     3926                     (setq val ($ *x862-arg-z*))))))))))
    39013927  val)
    39023928
     
    39553981                            (x862-new-vstack-lcell :node *x862-target-lcell-size* bits var)
    39563982                            (x862-adjust-vstack *x862-target-node-size*))
    3957                           (x862-vpush-register seg (x862-one-untargeted-reg-form seg val x8664::arg_z) :node var bits)))))
     3983                          (x862-vpush-register seg (x862-one-untargeted-reg-form seg val *x862-arg-z*) :node var bits)))))
    39583984                  (x862-set-var-ea seg var (or reg (x862-vloc-ea vloc closed-p)))
    39593985                  (if reg
     
    39613987                    (x862-note-top-cell var))
    39623988                  (when make-vcell
    3963                     (with-node-target (x8664::allocptr) closed
    3964                       (with-node-target (x8664::allocptr closed) vcell
     3989                    (with-node-target (*x862-allocptr*) closed
     3990                      (with-node-target (*x862-allocptr* closed) vcell
    39653991                        (x862-stack-to-register seg vloc closed)
    39663992                        (if closed-downward
     
    39954021          (compiler-bug "bind-var: var ~s was punted" var))
    39964022        (when make-vcell
    3997           (with-node-target (x8664::allocptr) closed
    3998             (with-node-target (x8664::allocptr closed) vcell
     4023          (with-node-target (*x862-allocptr*) closed
     4024            (with-node-target (*x862-allocptr* closed) vcell
    39994025              (x862-stack-to-register seg vloc closed)
    40004026              (if closed-downward
     
    40584084                     (t
    40594085                      (if ea-p
    4060                         (x862-store-ea seg value x8664::arg_z)
    4061                         (x862-one-targeted-reg-form seg value ($ x8664::arg_z)))
     4086                        (x862-store-ea seg value *x862-arg-z*)
     4087                        (x862-one-targeted-reg-form seg value ($ *x862-arg-z*)))
    40624088                      (! bind-interrupt-level))))
    40634089             (x862-open-undo $undointerruptlevel))
     
    40654091             (if (or nil-p self-p)
    40664092               (progn
    4067                  (x862-store-immediate seg (x862-symbol-value-cell sym) x8664::arg_z)
     4093                 (x862-store-immediate seg (x862-symbol-value-cell sym) *x862-arg-z*)
    40684094                 (if nil-p
    40694095                   (! bind-nil)
     
    40734099               (progn
    40744100                 (if ea-p
    4075                    (x862-store-ea seg value x8664::arg_z)
    4076                    (x862-one-targeted-reg-form seg value ($ x8664::arg_z)))
    4077                  (x862-store-immediate seg (x862-symbol-value-cell sym) ($ x8664::arg_y))
     4101                   (x862-store-ea seg value *x862-arg-z*)
     4102                   (x862-one-targeted-reg-form seg value ($ *x862-arg-z*)))
     4103                 (x862-store-immediate seg (x862-symbol-value-cell sym) ($ *x862-arg-y*))
    40784104                 (! bind)))
    40794105             (x862-open-undo $undospecial)))
     
    41334159               (if for-value
    41344160                 (progn
    4135                    (x862-one-targeted-reg-form seg val ($ x8664::arg_z))
     4161                   (x862-one-targeted-reg-form seg val ($ *x862-arg-z*))
    41364162                   (progn
    41374163                       (if intval
    4138                          (x862-lri seg x8664::imm0 intval)
    4139                          (! deref-macptr x8664::imm0 x8664::arg_z))
    4140                        (values x8664::imm0 x8664::arg_z)))
    4141                  (values (x862-macptr-arg-to-reg seg val ($ x8664::imm0 :mode :address)) nil))))
     4164                         (x862-lri seg *x862-imm0* intval)
     4165                         (! deref-macptr *x862-imm0* *x862-arg-z*))
     4166                       (values *x862-imm0* *x862-arg-z*)))
     4167                 (values (x862-macptr-arg-to-reg seg val ($ *x862-imm0* :mode :address)) nil))))
    41424168        (unless (typep offval '(signed-byte 32))
    41434169          (setq offval nil))
     
    41544180                      (with-imm-target () (ptr-reg :address)
    41554181                        (with-imm-target (ptr-reg) (offsetreg :signed-natural)
    4156                           (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ x8664::arg_z))
    4157                           (! fixnum->signed-natural offsetreg x8664::arg_z)
     4182                          (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ *x862-arg-z*))
     4183                          (! fixnum->signed-natural offsetreg *x862-arg-z*)
    41584184                          (! mem-set-constant-doubleword intval ptr-reg offsetreg)))))
    41594185               (if for-value
     
    41764202               (with-imm-target () (ptr-reg :address)
    41774203                 (with-imm-target (ptr-reg) (offset-reg :address)
    4178                    (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ x8664::arg_z))
    4179                    (! fixnum->signed-natural offset-reg x8664::arg_z)
     4204                   (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ *x862-arg-z*))
     4205                   (! fixnum->signed-natural offset-reg *x862-arg-z*)
    41804206                   (! fixnum-add2 ptr-reg offset-reg)
    41814207                   (x862-push-register seg ptr-reg)))
     
    42104236        (declare (fixnum size))
    42114237        (flet ((val-to-argz-and-imm0 ()
    4212                  (x862-one-targeted-reg-form seg val ($ x8664::arg_z))
     4238                 (x862-one-targeted-reg-form seg val ($ *x862-arg-z*))
    42134239                 (if (eq size 8)
    42144240                   (if signed
    42154241                     (! gets64)
    42164242                     (! getu64))
    4217                    (! fixnum->signed-natural x8664::imm0 x8664::arg_z))))
     4243                   (! fixnum->signed-natural x8664::imm0 *x862-arg-z*))))
    42184244
    42194245          (and offval (%i> (integer-length offval) 31) (setq offval nil))
     
    42394265                        (with-imm-target () (ptr-reg :address)
    42404266                          (with-imm-target (ptr-reg) (offsetreg :signed-natural)
    4241                             (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ x8664::arg_z))
    4242                             (! fixnum->signed-natural offsetreg x8664::arg_z)
     4267                            (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ *x862-arg-z*))
     4268                            (! fixnum->signed-natural offsetreg *x862-arg-z*)
    42434269                            (case size
    42444270                              (8 (! mem-set-constant-doubleword intval ptr-reg offsetreg))
     
    42634289                     (1 (! mem-set-c-byte x8664::imm0 ptr-reg offval))))
    42644290                 (if for-value
    4265                    (<- x8664::arg_z)))
     4291                   (<- *x862-arg-z*)))
    42664292                (t
    42674293                 (with-imm-target () (ptr-reg :address)
    42684294                   (with-imm-target (ptr-reg) (offset-reg :address)
    4269                      (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ x8664::arg_z))
    4270                      (! fixnum->signed-natural offset-reg x8664::arg_z)
     4295                     (x862-two-targeted-reg-forms seg ptr ptr-reg offset ($ *x862-arg-z*))
     4296                     (! fixnum->signed-natural offset-reg *x862-arg-z*)
    42714297                     (! fixnum-add2 ptr-reg offset-reg)
    42724298                     (x862-push-register seg ptr-reg)))
     
    42804306                     (1 (! mem-set-c-byte x8664::imm0 ptr-reg 0))))
    42814307                 (if for-value
    4282                    (< x8664::arg_z))))
     4308                   (< *x862-arg-z*))))
    42834309
    42844310          (^))))))
     
    43674393  (with-x86-local-vinsn-macros (seg vreg xfer)
    43684394    (when (or check-boundp vreg)
    4369       (unless vreg (setq vreg ($ x8664::arg_z)))
     4395      (unless vreg (setq vreg ($ *x862-arg-z*)))
    43704396      (if (eq sym '*interrupt-level*)
    43714397          (ensuring-node-target (target vreg)
     
    43824408                  (! ref-symbol-value-inline target src)
    43834409                  (! %ref-symbol-value-inline target src))))
    4384             (let* ((src ($ x8664::arg_z))
    4385                    (dest ($ x8664::arg_z)))
     4410            (let* ((src ($ *x862-arg-z*))
     4411                   (dest ($ *x862-arg-z*)))
    43864412              (x862-store-immediate seg (x862-symbol-value-cell sym) src)
    43874413              (if check-boundp
     
    43944420(defun x862-extract-charcode (seg vreg xfer char safe)
    43954421  (with-x86-local-vinsn-macros (seg vreg xfer)
    4396     (let* ((src (x862-one-untargeted-reg-form seg char x8664::arg_z)))
     4422    (let* ((src (x862-one-untargeted-reg-form seg char *x862-arg-z*)))
    43974423      (when safe
    43984424        (! trap-unless-character src))
     
    44074433    (setq safe nil))                    ; May also have been passed as NIL.
    44084434  (with-x86-local-vinsn-macros (seg vreg xfer)
    4409     (let* ((src (x862-one-untargeted-reg-form seg listform x8664::arg_z)))
     4435    (let* ((src (x862-one-untargeted-reg-form seg listform *x862-arg-z*)))
    44104436      (when safe
    44114437        (! trap-unless-list src))
     
    44734499                     (progn
    44744500                       (push nil pending)
    4475                        (x862-vpush-register seg (x862-one-untargeted-reg-form seg form x8664::arg_z)))))
     4501                       (x862-vpush-register seg (x862-one-untargeted-reg-form seg form *x862-arg-z*)))))
    44764502                 (x862-lri seg x8664::imm0 header)
    44774503                 (x862-lri seg x8664::imm1 (- (ash (logandc2 (+ n 2) 1) (arch::target-word-shift arch)) (target-arch-case  (:x8664 x8664::fulltag-misc))))
     
    45144540    (setq safe nil))                    ; May also have been passed as NIL.
    45154541  (with-x86-local-vinsn-macros (seg vreg xfer)
    4516     (multiple-value-bind (ptr-vreg val-vreg) (x862-two-targeted-reg-forms seg ptrform ($ x8664::arg_y) valform ($ x8664::arg_z))
     4542    (multiple-value-bind (ptr-vreg val-vreg) (x862-two-targeted-reg-forms seg ptrform ($ *x862-arg-y*) valform ($ *x862-arg-z*))
    45174543      (when safe
    45184544        (! trap-unless-cons ptr-vreg))
    45194545      (if setcdr
    4520         (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPrplacd) ptr-vreg val-vreg)
    4521         (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPrplaca) ptr-vreg val-vreg))
     4546        (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPrplacd) ptr-vreg val-vreg)
     4547        (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPrplaca) ptr-vreg val-vreg))
    45224548      (if returnptr
    45234549        (<- ptr-vreg)
     
    45944620        (setq xfer (logand (lognot $backend-mvpass-mask) xfer))
    45954621        (unless *x862-returning-values*
    4596           (x862-vpush-register seg x8664::arg_z)
     4622          (x862-vpush-register seg *x862-arg-z*)
    45974623          (x862-set-nargs seg 1)))
    45984624      (if (neq 0 xfer)
     
    47064732              (dotimes (i numundo) (x862-close-undo)))
    47074733            (progn
    4708               ;; There are some cases where storing thru x8664::arg_z
     4734              ;; There are some cases where storing thru *x862-arg-z*
    47094735              ;; can be avoided (stores to vlocs, specials, etc.) and
    47104736              ;; some other case where it can't ($test, $vpush.)  The
    47114737              ;; case of a null vd can certainly avoid it; the check
    47124738              ;; of numundo is to keep $acc boxed in case of nthrow.
    4713               (x862-form  seg (if (or vreg (not (%izerop numundo))) x8664::arg_z) nil body)
     4739              (x862-form  seg (if (or vreg (not (%izerop numundo))) *x862-arg-z*) nil body)
    47144740              (x862-unwind-set seg xfer old-stack)
    4715               (when vreg (<- x8664::arg_z))
     4741              (when vreg (<- *x862-arg-z*))
    47164742              (^))))))))
    47174743
     
    47964822            (when label
    47974823              (x862-vpush-label seg (aref *backend-labels* label)))
    4798             (x862-temp-push-node seg (x862-one-untargeted-reg-form seg fn x8664::arg_z))
     4824            (x862-temp-push-node seg (x862-one-untargeted-reg-form seg fn *x862-arg-z*))
    47994825            (x862-multiple-value-body seg (pop arglist))
    48004826            (x862-open-undo $undostkblk)
     
    48054831            (! recover-values-for-mvcall)
    48064832            (x862-close-undo)
    4807             (x862-temp-pop-node seg x8664::temp0)
    4808             (x862-invoke-fn seg x8664::temp0 nil nil xfer label)
     4833            (x862-temp-pop-node seg *x862-temp0*)
     4834            (x862-invoke-fn seg *x862-temp0* nil nil xfer label)
    48094835            (when label
    48104836              ;; Pushed a label earlier, then returned to it.
     
    48174843                (^)))
    48184844            (progn
    4819               (<- x8664::arg_z)
     4845              (<- *x862-arg-z*)
    48204846              (^))))))))
    48214847
     
    49594985                     (let* ((tag-label (backend-get-next-label))
    49604986                            (tag-label-value (aref *backend-labels* tag-label)))
    4961                        (x862-lri seg x8664::imm0 (ash numnthrow *x862-target-fixnum-shift*))
     4987                       (x862-lri seg *x862-imm0* (ash numnthrow *x862-target-fixnum-shift*))
    49624988                       (if retval
    49634989                         (! nthrowvalues tag-label-value)
     
    50025028                  (if retval
    50035029                    (progn
    5004                       (x862-lri seg x8664::imm0 vdiff)
     5030                      (x862-lri seg *x862-imm0* vdiff)
    50055031                      (! slide-values))
    50065032                    (! adjust-vsp vdiff)))))
     
    50255051                (setq n 0))
    50265052              (if *x862-open-code-inline*
    5027                 (let* ((*available-backend-node-temps* (bitclr x8664::arg_z (bitclr x8664::rcx *available-backend-node-temps*))))
     5053                (let* ((*available-backend-node-temps* (bitclr *x862-arg-z* (bitclr x8664::rcx *available-backend-node-temps*))))
    50285054                  (! unbind-interrupt-level-inline))
    50295055                (! unbind-interrupt-level)))
     
    50685094        (if enclosing-ea
    50695095          (progn
    5070             (x862-store-ea seg enclosing-ea x8664::arg_z)
     5096            (x862-store-ea seg enclosing-ea *x862-arg-z*)
    50715097            (! destructuring-bind-inner))
    50725098          (! destructuring-bind)))
     
    54375463      (if idx-subprim
    54385464        (setq subprim idx-subprim)
    5439         (if index (! lri ($ x8664::imm0) (ash index *x862-target-fixnum-shift*))))
     5465        (if index (! lri ($ *x862-imm0*) (ash index *x862-target-fixnum-shift*))))
    54405466      (if tail-p
    54415467        (! jump-subprim subprim)
    54425468        (progn
    54435469          (! call-subprim subprim)
    5444           (<- ($ x8664::arg_z))
     5470          (<- ($ *x862-arg-z*))
    54455471          (^))))))
    54465472
    54475473(defun x862-unary-builtin (seg vreg xfer name form)
    54485474  (with-x86-local-vinsn-macros (seg)
    5449     (x862-one-targeted-reg-form seg form ($ x8664::arg_z))
     5475    (x862-one-targeted-reg-form seg form ($ *x862-arg-z*))
    54505476    (x862-fixed-call-builtin seg vreg xfer name (subprim-name->offset '.SPcallbuiltin1))))
    54515477
    54525478(defun x862-binary-builtin (seg vreg xfer name form1 form2)
    54535479  (with-x86-local-vinsn-macros (seg)
    5454     (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z))
     5480    (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*))
    54555481    (x862-fixed-call-builtin seg vreg xfer name (subprim-name->offset '.SPcallbuiltin2))))
    54565482
    54575483(defun x862-ternary-builtin (seg vreg xfer name form1 form2 form3)
    54585484  (with-x86-local-vinsn-macros (seg)
    5459     (x862-three-targeted-reg-forms seg form1 ($ x8664::arg_x) form2 ($ x8664::arg_y) form3 ($ x8664::arg_z))
     5485    (x862-three-targeted-reg-forms seg form1 ($ x8664::arg_x) form2 ($ *x862-arg-y*) form3 ($ *x862-arg-z*))
    54605486    (x862-fixed-call-builtin seg vreg xfer name (subprim-name->offset '.SPcallbuiltin3))))
    54615487
     
    55405566                       (! check-max-nargs max-args)))
    55415567                (if (not (or rest keys))
    5542                   (if (<= (+ num-fixed num-opt) $numx8664argregs)
     5568                  (if (<= (+ num-fixed num-opt) *x862-target-num-arg-regs*)
    55435569                    (! save-lisp-context-no-stack-args)
    55445570                    (! save-lisp-context-variable-arg-count))
     
    55635589                    (x862-lri seg x8664::temp1 (ash flags *x862-target-fixnum-shift*))
    55645590                    (unless (= nprev 0)
    5565                       (x862-lri seg x8664::imm0 (ash nprev *x862-target-fixnum-shift*)))
     5591                      (x862-lri seg *x862-imm0* (ash nprev *x862-target-fixnum-shift*)))
    55665592                    (x86-immediate-label keyvect)
    55675593                    (if (= 0 nprev)
     
    55845610                        (declare (fixnum nprev))
    55855611                        (unless simple
    5586                           (x862-lri seg x8664::imm0 (ash nprev *x862-target-fixnum-shift*)))
     5612                          (x862-lri seg *x862-imm0* (ash nprev *x862-target-fixnum-shift*)))
    55875613                        (if stack-consed-rest
    55885614                          (if simple
     
    56365662                (! ref-constant reg (x86-immediate-label (car constant))))))
    56375663          (when (and (not (or opt rest keys))
    5638                      (<= max-args $numx8664argregs)
     5664                     (<= max-args *x862-target-num-arg-regs*)
    56395665                     (not (some #'null arg-regs)))
    56405666            (setq *x862-tail-vsp* *x862-vstack*
     
    57305756        (x862-push-register seg
    57315757                            (if (or node-p crf-p)
    5732                               (x862-one-untargeted-reg-form seg first x8664::arg_z)
     5758                              (x862-one-untargeted-reg-form seg first *x862-arg-z*)
    57335759                              (x862-one-targeted-reg-form seg first vreg)))
    57345760        (dolist (form forms)
     
    57365762        (if crf-p
    57375763          (progn
    5738             (x862-vpop-register seg x8664::arg_z)
    5739             (<- x8664::arg_z))
     5764            (x862-vpop-register seg *x862-arg-z*)
     5765            (<- *x862-arg-z*))
    57405766          (x862-pop-register seg vreg))
    57415767        (^)))))
     
    57515777
    57525778(defx862 x862-%slot-ref %slot-ref (seg vreg xfer instance idx)
    5753   (ensuring-node-target (target (or vreg ($ x8664::arg_z)))
     5779  (ensuring-node-target (target (or vreg ($ *x862-arg-z*)))
    57545780    (multiple-value-bind (v i)
    5755         (x862-two-untargeted-reg-forms seg instance x8664::arg_y idx x8664::arg_z)
     5781        (x862-two-untargeted-reg-forms seg instance *x862-arg-y* idx *x862-arg-z*)
    57565782      (unless *x862-reckless*
    57575783        (! check-misc-bound i v))
     
    57955821    (let* ((tagreg x8664::imm0))
    57965822      (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    5797         (! extract-fulltag tagreg (x862-one-untargeted-reg-form seg form x8664::arg_z))
     5823        (! extract-fulltag tagreg (x862-one-untargeted-reg-form seg form *x862-arg-z*))
    57985824        (! compare-u8-constant tagreg x8664::fulltag-cons)
    57995825        (regspec-crf-gpr-case
     
    58125838      (x862-form seg nil nil y)
    58135839      (x862-form seg nil xfer z))
    5814     (multiple-value-bind (yreg zreg) (x862-two-untargeted-reg-forms seg y x8664::arg_y z x8664::arg_z)
     5840    (multiple-value-bind (yreg zreg) (x862-two-untargeted-reg-forms seg y *x862-arg-y* z *x862-arg-z*)
    58155841      (ensuring-node-target (target vreg)
    58165842        (! cons target yreg zreg))
     
    58705896            (x862-set-nargs seg (x862-formlist seg all-on-stack nil))
    58715897            (! gvector))
    5872           (<- x8664::arg_z)
     5898          (<- *x862-arg-z*)
    58735899          (^))
    58745900        (x862-allocate-initialized-gvector seg vreg xfer subtag (cdr all-on-stack))))))
     
    58965922            (x862-one-targeted-reg-form seg otherform target)
    58975923            (! %logior-c target target (ash fixval *x862-target-fixnum-shift*))))
    5898          (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     5924         (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    58995925            (if vreg (ensuring-node-target (target vreg) (! %logior2 target r1 r2)))))
    59005926      (^))))
     
    59185944            (x862-one-targeted-reg-form seg otherform target)
    59195945            (! %logand-c target target (ash fixval *x862-target-fixnum-shift*))))
    5920          (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*)
    59215947            (if vreg (ensuring-node-target (target vreg) (! %logand2 target r1 r2)))))
    59225948      (^))))
     
    59375963            (x862-one-targeted-reg-form seg otherform target)
    59385964            (! %logxor-c target target (ash fixval *x862-target-fixnum-shift*))))
    5939          (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     5965         (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    59405966            (if vreg (ensuring-node-target (target vreg) (! %logxor2 target r1 r2)))))
    59415967      (^))))
     
    59735999(defx862 x862-istruct-typep istruct-typep (seg vreg xfer cc form type)
    59746000  (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    5975     (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form x8664::arg_y type x8664::arg_z)
     6001    (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form *x862-arg-y* type *x862-arg-z*)
    59766002      (! set-z-flag-if-istruct-typep r1 r2)
    59776003      (regspec-crf-gpr-case
     
    59926018    (progn
    59936019      (unboxed-other-case (vreg :u8)
    5994         (! extract-tag vreg (x862-one-untargeted-reg-form seg node x8664::arg_z))
     6020        (! extract-tag vreg (x862-one-untargeted-reg-form seg node *x862-arg-z*))
    59956021        (ensuring-node-target (target vreg)
    5996          (! extract-tag-fixnum target (x862-one-untargeted-reg-form seg node x8664::arg_z))))
     6022         (! extract-tag-fixnum target (x862-one-untargeted-reg-form seg node *x862-arg-z*))))
    59976023      (^))))
    59986024
     
    60036029    (progn
    60046030      (unboxed-other-case (vreg :u8)
    6005         (! extract-fulltag vreg (x862-one-untargeted-reg-form seg node x8664::arg_z))
     6031        (! extract-fulltag vreg (x862-one-untargeted-reg-form seg node *x862-arg-z*))
    60066032        (ensuring-node-target (target vreg)
    6007           (! extract-fulltag-fixnum target (x862-one-untargeted-reg-form seg node x8664::arg_z))))
     6033          (! extract-fulltag-fixnum target (x862-one-untargeted-reg-form seg node *x862-arg-z*))))
    60086034      (^))))
    60096035
     
    60146040    (progn
    60156041      (unboxed-other-case (vreg :u8)
    6016          (! extract-typecode vreg (x862-one-untargeted-reg-form seg node x8664::arg_z))
    6017          (let* ((reg (x862-one-untargeted-reg-form seg node (if (eq (hard-regspec-value vreg) x8664::arg_z)
    6018                                                               x8664::arg_y x8664::arg_z))))
     6042         (! extract-typecode vreg (x862-one-untargeted-reg-form seg node *x862-arg-z*))
     6043         (let* ((reg (x862-one-untargeted-reg-form seg node (if (eq (hard-regspec-value vreg) *x862-arg-z*)
     6044                                                              *x862-arg-y* *x862-arg-z*))))
    60196045           (ensuring-node-target (target vreg)
    60206046             (! extract-typecode-fixnum target reg ))))
     
    60226048
    60236049(defx862 x862-setq-special setq-special (seg vreg xfer sym val)
    6024   (let* ((symreg ($ x8664::arg_y))
    6025          (valreg ($ x8664::arg_z)))
     6050  (let* ((symreg ($ *x862-arg-y*))
     6051         (valreg ($ *x862-arg-z*)))
    60266052    (x862-one-targeted-reg-form seg val valreg)
    60276053    (x862-store-immediate seg (x862-symbol-value-cell sym) symreg)
     
    60506076         end-of-block
    60516077         last-cd
    6052          (dest (if (backend-crf-p vreg) x8664::arg_z vreg)))
     6078         (dest (if (backend-crf-p vreg) *x862-arg-z* vreg)))
    60536079    (if need-label
    60546080      (setq end-of-block (backend-get-next-label)))
     
    60706096
    60716097(defx862 x862-uvsize uvsize (seg vreg xfer v)
    6072   (let* ((misc-reg (x862-one-untargeted-reg-form seg v x8664::arg_z)))
     6098  (let* ((misc-reg (x862-one-untargeted-reg-form seg v *x862-arg-z*)))
    60736099    (unless *x862-reckless* (! trap-unless-uvector misc-reg))
    60746100    (if vreg
     
    60866112      (ensuring-node-target (target vreg)
    60876113        (if const
    6088           (let* ((src (x862-one-untargeted-reg-form seg form2 x8664::arg_z)))
     6114          (let* ((src (x862-one-untargeted-reg-form seg form2 *x862-arg-z*)))
    60896115            (if (<= const max)
    60906116              (! %ilsl-c target const src)
    60916117              (!  lri target 0)))
    6092           (multiple-value-bind (count src) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     6118          (multiple-value-bind (count src) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    60936119            (! %ilsl target count src))))
    60946120      (^))))
    60956121
    60966122(defx862 x862-endp endp (seg vreg xfer cc form)
    6097   (let* ((formreg (x862-one-untargeted-reg-form seg form x8664::arg_z)))
     6123  (let* ((formreg (x862-one-untargeted-reg-form seg form *x862-arg-z*)))
    60986124    (! trap-unless-list formreg)
    60996125    (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
     
    61136139(defx862 x862-%schar %schar (seg vreg xfer str idx)
    61146140  (multiple-value-bind (src unscaled-idx)
    6115       (x862-two-untargeted-reg-forms seg str x8664::arg_y idx x8664::arg_z)
     6141      (x862-two-untargeted-reg-forms seg str *x862-arg-y* idx *x862-arg-z*)
    61166142    (if vreg
    61176143      (ensuring-node-target (target vreg)
     
    61256151      (x862-three-untargeted-reg-forms seg
    61266152                                       str x8664::arg_x
    6127                                        idx x8664::arg_y
    6128                                        char x8664::arg_z)
     6153                                       idx *x862-arg-y*
     6154                                       char *x862-arg-z*)
    61296155    (case (arch::target-char-code-limit (backend-target-arch *target-backend*))
    61306156      (256 (! %set-schar8 src unscaled-idx char))
     
    61356161(defx862 x862-%set-scharcode %set-scharcode (seg vreg xfer str idx char)
    61366162  (multiple-value-bind (src unscaled-idx char)
    6137       (x862-three-untargeted-reg-forms seg str x8664::arg_x idx x8664::arg_y
    6138                                        char x8664::arg_z)
     6163      (x862-three-untargeted-reg-forms seg str x8664::arg_x idx *x862-arg-y*
     6164                                       char *x862-arg-z*)
    61396165    (case (arch::target-char-code-limit (backend-target-arch *target-backend*))
    61406166      (256 (! %set-scharcode8 src unscaled-idx char))
     
    61456171(defx862 x862-%scharcode %scharcode (seg vreg xfer str idx)
    61466172  (multiple-value-bind (src unscaled-idx)
    6147       (x862-two-untargeted-reg-forms seg str x8664::arg_y idx x8664::arg_z)
     6173      (x862-two-untargeted-reg-forms seg str *x862-arg-y* idx *x862-arg-z*)
    61486174    (if vreg
    61496175      (ensuring-node-target (target vreg)
     
    61566182
    61576183(defx862 x862-code-char code-char (seg vreg xfer c)
    6158   (let* ((reg (x862-one-untargeted-reg-form seg c x8664::arg_z)))
     6184  (let* ((reg (x862-one-untargeted-reg-form seg c *x862-arg-z*)))
    61596185    ;; Typecheck even if result unused.
    61606186    (! require-char-code reg)
     
    61666192#+not-yet
    61676193(defx862 x862-%valid-code-char %valid-code-char (seg vreg xfer c)
    6168   (let* ((reg (x862-one-untargeted-reg-form seg c x8664::arg_z)))
     6194  (let* ((reg (x862-one-untargeted-reg-form seg c *x862-arg-z*)))
    61696195    ;; Typecheck even if result unused.
    61706196    (unless *x862-reckless* (! require-char-code reg))
     
    61836209                   (and (acode-p f1)
    61846210                        (eq (acode-operator f1) (%nx1-operator immediate))))
    6185                (x862-compare-register-to-constant seg vreg xfer (x862-one-untargeted-reg-form seg form2 ($ x8664::arg_z)) cr-bit true-p f1))
     6211               (x862-compare-register-to-constant seg vreg xfer (x862-one-untargeted-reg-form seg form2 ($ *x862-arg-z*)) cr-bit true-p f1))
    61866212              ((or (eq f2 *nx-nil*)
    61876213                   (eq f2 *nx-t*)
     
    61896215                        (eq (acode-operator f2) (%nx1-operator immediate))))
    61906216               (x862-compare-register-to-constant seg vreg xfer
    6191                                                   (x862-one-untargeted-reg-form seg form1 ($ x8664::arg_z))
     6217                                                  (x862-one-untargeted-reg-form seg form1 ($ *x862-arg-z*))
    61926218                                                  cr-bit true-p f2))
    61936219              (t (x862-compare seg vreg xfer form1 form2 cr-bit true-p)))))))
     
    62296255           (done (backend-get-next-label)))
    62306256      (if otherform
    6231         (x862-one-targeted-reg-form seg otherform ($ x8664::arg_y))
    6232         (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z)))
     6257        (x862-one-targeted-reg-form seg otherform ($ *x862-arg-y*))
     6258        (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*)))
    62336259      (if otherform
    62346260        (unless (acode-fixnum-form-p otherform)
    6235           (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)))
     6261          (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)))
    62366262        (if (acode-fixnum-form-p form1)
    6237           (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
     6263          (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
    62386264          (if (acode-fixnum-form-p form2)
    6239             (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6240             (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line)))))
     6265            (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6266            (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))))
    62416267      (if otherform
    62426268        (if (zerop fixval)
    6243           (! compare-reg-to-zero ($ x8664::arg_y))
    6244           (! compare-s32-constant ($ x8664::arg_y) (ash fixval x8664::fixnumshift)))
    6245         (! compare ($ x8664::arg_y) ($ x8664::arg_z)))
     6269          (! compare-reg-to-zero ($ *x862-arg-y*))
     6270          (! compare-s32-constant ($ *x862-arg-y*) (ash fixval *x862-target-fixnum-shift*)))
     6271        (! compare ($ *x862-arg-y*) ($ *x862-arg-z*)))
    62466272      (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    62476273        (when otherform
     
    62506276        (if (not true-p)
    62516277          (setq cr-bit (logxor 1 cr-bit)))
    6252         (! cr-bit->boolean ($ x8664::arg_z) cr-bit)
     6278        (! cr-bit->boolean ($ *x862-arg-z*) cr-bit)
    62536279        (-> done)
    62546280        (@ out-of-line)
    62556281        (when otherform
    6256           (x862-lri seg ($ x8664::arg_z) (ash fixval x8664::fixnumshift))
     6282          (x862-lri seg ($ *x862-arg-z*) (ash fixval *x862-target-fixnum-shift*))
    62576283          (unless (or fix2 (eq cr-bit x86::x86-e-bits))
    6258             (! xchg-registers ($ x8664::arg_z) ($ x8664::arg_y))))
     6284            (! xchg-registers ($ *x862-arg-z*) ($ *x862-arg-y*))))
    62596285        (let* ((index (arch::builtin-function-name-offset name))
    62606286               (idx-subprim (x862-builtin-index-subprim index)))
    6261           (! call-subprim-2 ($ x8664::arg_z) idx-subprim ($ x8664::arg_y) ($ x8664::arg_z)))
     6287          (! call-subprim-2 ($ *x862-arg-z*) idx-subprim ($ *x862-arg-y*) ($ *x862-arg-z*)))
    62626288        (@ done)
    6263         (<- ($ x8664::arg_z))
     6289        (<- ($ *x862-arg-z*))
    62646290        (^)))))
    62656291         
     
    62726298    (progn
    62736299      (ensuring-node-target (target vreg)
    6274         (! sign-extend-halfword target (x862-one-untargeted-reg-form seg form x8664::arg_z)))
     6300        (! sign-extend-halfword target (x862-one-untargeted-reg-form seg form *x862-arg-z*)))
    62756301      (^))))
    62766302
     
    62796305  (! list)
    62806306  (when vreg
    6281     (<- x8664::arg_z))
     6307    (<- *x862-arg-z*))
    62826308  (^))
    62836309
     
    63176343                                                                   (or (null vreg) (eq ea vreg)))
    63186344                                                            ea
    6319                                                             x8664::arg_z))))
     6345                                                            *x862-arg-z*))))
    63206346      (x862-do-lexical-setq seg vreg ea valreg))
    63216347    (^)))
     
    63606386      (let* ((fixbit (acode-fixnum-form-p bitnum)))
    63616387        (if fixbit
    6362           (let* ((reg (x862-one-untargeted-reg-form seg form x8664::arg_z))
     6388          (let* ((reg (x862-one-untargeted-reg-form seg form *x862-arg-z*))
    63636389                 (x86-bit (min (+ fixbit *x862-target-fixnum-shift*) (1- *x862-target-bits-in-word*))))
    63646390            (! set-c-flag-if-constant-logbitp x86-bit reg))
    6365           (multiple-value-bind (rbit rform) (x862-two-untargeted-reg-forms seg bitnum x8664::arg_y form x8664::arg_z)
     6391          (multiple-value-bind (rbit rform) (x862-two-untargeted-reg-forms seg bitnum *x862-arg-y* form *x862-arg-z*)
    63666392            (! set-c-flag-if-variable-logbitp rbit rform)))
    63676393        (regspec-crf-gpr-case
     
    63776403
    63786404(defx862 x862-uvref uvref (seg vreg xfer vector index)
    6379   (x862-two-targeted-reg-forms seg vector ($ x8664::arg_y) index ($ x8664::arg_z))
     6405  (x862-two-targeted-reg-forms seg vector ($ *x862-arg-y*) index ($ *x862-arg-z*))
    63806406  (! misc-ref)
    6381   (<- ($ x8664::arg_z))
     6407  (<- ($ *x862-arg-z*))
    63826408  (^))
    63836409
    63846410(defx862 x862-uvset uvset (seg vreg xfer vector index value)
    6385   (x862-three-targeted-reg-forms seg vector ($ x8664::arg_x) index ($ x8664::arg_y) value ($ x8664::arg_z))
     6411  (x862-three-targeted-reg-forms seg vector ($ x8664::arg_x) index ($ *x862-arg-y*) value ($ *x862-arg-z*))
    63866412  (! misc-set)
    6387   (<- ($ x8664::arg_z))
     6413  (<- ($ *x862-arg-z*))
    63886414  (^))
    63896415
     
    64496475      (x862-restore-full-lisp-context seg))
    64506476    (unless idx-subprim
    6451       (! lri x8664::imm0 (ash idx *x862-target-fixnum-shift*))
     6477      (! lri *x862-imm0* (ash idx *x862-target-fixnum-shift*))
    64526478      (when (eql subprim (subprim-name->offset '.SPcallbuiltin))
    64536479        (x862-set-nargs seg nargs)))
     
    64566482      (progn
    64576483        (! call-subprim subprim)
    6458         (<- x8664::arg_z)
     6484        (<- *x862-arg-z*)
    64596485        (^)))))
    64606486     
     
    64856511        (setq xfer nil))
    64866512      (if both-single-valued            ; it's implied that we're returning
    6487         (let* ((result x8664::arg_z))
     6513        (let* ((result *x862-arg-z*))
    64886514          (let ((merge-else-branch-label (if (nx-null false) (x862-find-nilret-label))))
    64896515            (x862-conditional-form seg (x862-make-compound-cd 0 falselabel) testform)
     
    65566582         (vstack *x862-vstack*)
    65576583         (cstack *x862-cstack*)
    6558          (dest (if (backend-crf-p vreg) vreg (if vreg x8664::arg_z (available-crf-temp *available-backend-crf-temps*))))
     6584         (dest (if (backend-crf-p vreg) vreg (if vreg *x862-arg-z* (available-crf-temp *available-backend-crf-temps*))))
    65596585         (cd1 (x862-make-compound-cd
    6560                (if (eq dest x8664::arg_z) tag1 (x862-cd-merge (x862-cd-true xfer) tag1)) 0)))
     6586               (if (eq dest *x862-arg-z*) tag1 (x862-cd-merge (x862-cd-true xfer) tag1)) 0)))
    65616587    (while (cdr forms)
    6562       (x862-form seg dest (if (eq dest x8664::arg_z) nil cd1) (car forms))
    6563       (when (eq dest x8664::arg_z)
     6588      (x862-form seg dest (if (eq dest *x862-arg-z*) nil cd1) (car forms))
     6589      (when (eq dest *x862-arg-z*)
    65646590        (with-crf-target () val-crf
    65656591          (x862-copy-register seg val-crf dest)
     
    65696595      (progn (x862-multiple-value-body seg (car forms))
    65706596             (let* ((*x862-returning-values* t)) (x862-branch seg (x862-cd-merge xfer tag2))))
    6571       (x862-form seg  vreg (if (eq dest x8664::arg_z) (x862-cd-merge xfer tag2) xfer) (car forms)))
     6597      (x862-form seg  vreg (if (eq dest *x862-arg-z*) (x862-cd-merge xfer tag2) xfer) (car forms)))
    65726598    (setq *x862-vstack* vstack *x862-cstack* cstack)
    65736599    (@ tag1)
    6574     (when (eq dest x8664::arg_z)
    6575       (<- x8664::arg_z)
     6600    (when (eq dest *x862-arg-z*)
     6601      (<- *x862-arg-z*)
    65766602      (^))
    65776603    (@ tag2)))
     
    65896615      (x862-set-nargs seg nargs)
    65906616      (! list)
    6591       (<- x8664::arg_z)))
     6617      (<- *x862-arg-z*)))
    65926618  (^))
    65936619
     
    66036629        (x862-set-nargs seg (1- nargs))
    66046630        (! list*))
    6605       (<- x8664::arg_z)))
     6631      (<- *x862-arg-z*)))
    66066632  (^))
    66076633
     
    66216647      (x862-inline-add2 seg vreg xfer form1 (make-acode (%nx1-operator fixnum) (- v2)))
    66226648      (with-x86-local-vinsn-macros (seg vreg xfer)
    6623         (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z))
     6649        (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*))
    66246650    (let* ((out-of-line (backend-get-next-label))
    66256651           (done (backend-get-next-label)))
    66266652      (ensuring-node-target (target vreg)
    66276653        (if (acode-fixnum-form-p form1)
    6628           (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
     6654          (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
    66296655          (if (acode-fixnum-form-p form2)
    6630             (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6631             (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line))))
    6632         (! fixnum-sub2 ($ x8664::arg_z) ($ x8664::arg_y) ($ x8664::arg_z))
    6633         (x862-check-fixnum-overflow seg ($ x8664::arg_z) done)
     6656            (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6657            (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line))))
     6658        (! fixnum-sub2 ($ *x862-arg-z*) ($ *x862-arg-y*) ($ *x862-arg-z*))
     6659        (x862-check-fixnum-overflow seg ($ *x862-arg-z*) done)
    66346660        (@ out-of-line)
    6635         (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPbuiltin-minus) ($ x8664::arg_y) ($ x8664::arg_z))
     6661        (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPbuiltin-minus) ($ *x862-arg-y*) ($ *x862-arg-z*))
    66366662        (@ done)
    6637         (x862-copy-register seg target ($ x8664::arg_z)))
     6663        (x862-copy-register seg target ($ *x862-arg-z*)))
    66386664      (^))))))
    66396665
     
    66516677                          form1))))
    66526678      (if otherform
    6653         (x862-one-targeted-reg-form seg otherform ($ x8664::arg_z))
    6654         (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z)))
     6679        (x862-one-targeted-reg-form seg otherform ($ *x862-arg-z*))
     6680        (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*)))
    66556681      (let* ((out-of-line (backend-get-next-label))
    66566682             (done (backend-get-next-label)))
     
    66596685          (if otherform
    66606686            (unless (acode-fixnum-form-p otherform)
    6661               (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line)))         
     6687              (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))         
    66626688            (if (acode-fixnum-form-p form1)
    6663               (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
     6689              (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
    66646690              (if (acode-fixnum-form-p form2)
    6665                 (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6666                 (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line)))))
     6691                (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6692                (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))))
    66676693          (if otherform
    6668             (! add-constant ($ x8664::arg_z) (ash (or fix1 fix2) *x862-target-fixnum-shift*))
    6669             (! fixnum-add2 ($ x8664::arg_z) ($ x8664::arg_y)))
    6670           (x862-check-fixnum-overflow seg ($ x8664::arg_z) done)
     6694            (! add-constant ($ *x862-arg-z*) (ash (or fix1 fix2) *x862-target-fixnum-shift*))
     6695            (! fixnum-add2 ($ *x862-arg-z*) ($ *x862-arg-y*)))
     6696          (x862-check-fixnum-overflow seg ($ *x862-arg-z*) done)
    66716697          (@ out-of-line)
    66726698          (if otherform
    6673             (x862-lri seg ($ x8664::arg_y) (ash (or fix1 fix2) *x862-target-fixnum-shift*)))
    6674           (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPbuiltin-plus) ($ x8664::arg_y) ($ x8664::arg_z))
     6699            (x862-lri seg ($ *x862-arg-y*) (ash (or fix1 fix2) *x862-target-fixnum-shift*)))
     6700          (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPbuiltin-plus) ($ *x862-arg-y*) ($ *x862-arg-z*))
    66756701          (@ done)
    6676           (x862-copy-register seg target ($ x8664::arg_z)))
     6702          (x862-copy-register seg target ($ *x862-arg-z*)))
    66776703        (^)))))
    66786704           
     
    68196845            (ensuring-node-target (target vreg)
    68206846              (if otherform
    6821                 (x862-one-targeted-reg-form seg otherform ($ x8664::arg_z))
    6822                 (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z)))
     6847                (x862-one-targeted-reg-form seg otherform ($ *x862-arg-z*))
     6848                (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*)))
    68236849              (if otherform
    68246850                (unless (acode-fixnum-form-p otherform)
    6825                   (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line)))
     6851                  (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))
    68266852                (if (acode-fixnum-form-p form1)
    6827                   (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
     6853                  (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
    68286854                  (if (acode-fixnum-form-p form2)
    6829                     (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6830                     (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line)))))
     6855                    (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6856                    (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))))
    68316857              (if otherform
    6832                 (! %logior-c ($ x8664::arg_z) ($ x8664::arg_z) (ash fixval x8664::fixnumshift))
    6833                 (! %logior2 ($ x8664::arg_z) ($ x8664::arg_z) ($ x8664::arg_y)))
     6858                (! %logior-c ($ *x862-arg-z*) ($ *x862-arg-z*) (ash fixval *x862-target-fixnum-shift*))
     6859                (! %logior2 ($ *x862-arg-z*) ($ *x862-arg-z*) ($ *x862-arg-y*)))
    68346860              (-> done)
    68356861              (@ out-of-line)
    68366862              (if otherform
    6837                 (x862-lri seg ($ x8664::arg_y) (ash fixval x8664::fixnumshift)))
    6838               (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPbuiltin-logior) ($ x8664::arg_y) ($ x8664::arg_z))
     6863                (x862-lri seg ($ *x862-arg-y*) (ash fixval *x862-target-fixnum-shift*)))
     6864              (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPbuiltin-logior) ($ *x862-arg-y*) ($ *x862-arg-z*))
    68396865              (@ done)
    6840               (x862-copy-register seg target ($ x8664::arg_z)))
     6866              (x862-copy-register seg target ($ *x862-arg-z*)))
    68416867            (^)))))))
    68426868
     
    68646890            (ensuring-node-target (target vreg)
    68656891              (if otherform
    6866                 (x862-one-targeted-reg-form seg otherform ($ x8664::arg_z))
    6867                 (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z)))
     6892                (x862-one-targeted-reg-form seg otherform ($ *x862-arg-z*))
     6893                (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*)))
    68686894              (if otherform
    68696895                (unless (acode-fixnum-form-p otherform)
    6870                   (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line)))
     6896                  (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))
    68716897                (if (acode-fixnum-form-p form1)
    6872                   (! branch-unless-arg-fixnum ($ x8664::arg_z) (aref *backend-labels* out-of-line))
     6898                  (! branch-unless-arg-fixnum ($ *x862-arg-z*) (aref *backend-labels* out-of-line))
    68736899                  (if (acode-fixnum-form-p form2)
    6874                     (! branch-unless-arg-fixnum ($ x8664::arg_y) (aref *backend-labels* out-of-line)) 
    6875                     (! branch-unless-both-args-fixnums ($ x8664::arg_y) ($ x8664::arg_z) (aref *backend-labels* out-of-line)))))
     6900                    (! branch-unless-arg-fixnum ($ *x862-arg-y*) (aref *backend-labels* out-of-line)) 
     6901                    (! branch-unless-both-args-fixnums ($ *x862-arg-y*) ($ *x862-arg-z*) (aref *backend-labels* out-of-line)))))
    68766902              (if otherform
    6877                 (! %logand-c ($ x8664::arg_z) ($ x8664::arg_z) (ash fixval x8664::fixnumshift))
    6878                 (! %logand2 ($ x8664::arg_z) ($ x8664::arg_z) ($ x8664::arg_y)))
     6903                (! %logand-c ($ *x862-arg-z*) ($ *x862-arg-z*) (ash fixval *x862-target-fixnum-shift*))
     6904                (! %logand2 ($ *x862-arg-z*) ($ *x862-arg-z*) ($ *x862-arg-y*)))
    68796905              (-> done)
    68806906              (@ out-of-line)
    68816907              (if otherform
    6882                 (x862-lri seg ($ x8664::arg_y) (ash fixval x8664::fixnumshift)))
    6883               (! call-subprim-2 ($ x8664::arg_z) (subprim-name->offset '.SPbuiltin-logand) ($ x8664::arg_y) ($ x8664::arg_z))
     6908                (x862-lri seg ($ *x862-arg-y*) (ash fixval *x862-target-fixnum-shift*)))
     6909              (! call-subprim-2 ($ *x862-arg-z*) (subprim-name->offset '.SPbuiltin-logand) ($ *x862-arg-y*) ($ *x862-arg-z*))
    68846910              (@ done)
    6885               (x862-copy-register seg target ($ x8664::arg_z)))
     6911              (x862-copy-register seg target ($ *x862-arg-z*)))
    68866912            (^)))))))
    68876913
     
    69666992                         (! add-constant3 target reg constant))))))
    69676993               (if (not overflow)
    6968                  (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     6994                 (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    69696995                   ;; This isn't guaranteed to set the overflow flag,
    69706996                   ;; but may do so.
     
    69726998                     (! fixnum-add3 target r1 r2)))
    69736999                 (ensuring-node-target (target vreg)
    6974                    (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 x8664::arg_y form2 x8664::arg_z)
     7000                   (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg form1 *x862-arg-y* form2 *x862-arg-z*)
    69757001                     (cond ((= (hard-regspec-value target)
    69767002                               (hard-regspec-value r1))
     
    70067032              (if (and fix1 fix2 (not overflow))
    70077033                (x862-lri seg vreg (ash (- fix1 fix2) *x862-target-fixnum-shift*))
    7008                 (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg num1 x8664::arg_y num2 x8664::arg_z)
     7034                (multiple-value-bind (r1 r2) (x862-two-untargeted-reg-forms seg num1 *x862-arg-y* num2 *x862-arg-z*)
    70097035                      ;; This isn't guaranteed to set the overflow flag,
    70107036                      ;; but may do so.
     
    70267052        (x862-lri seg vreg (ash (* fix1 fix2) *x862-target-fixnum-shift*))
    70277053        (if other
    7028           (! multiply-immediate vreg (x862-one-untargeted-reg-form seg other x8664::arg_z) (or fix1 fix2))
    7029           (multiple-value-bind (rx ry) (x862-two-untargeted-reg-forms seg num1 x8664::arg_y num2 x8664::arg_z)
     7054          (! multiply-immediate vreg (x862-one-untargeted-reg-form seg other *x862-arg-z*) (or fix1 fix2))
     7055          (multiple-value-bind (rx ry) (x862-two-untargeted-reg-forms seg num1 *x862-arg-y* num2 *x862-arg-z*)
    70307056            (ensuring-node-target (target vreg)
    70317057              (! multiply-fixnums target rx ry)))))
     
    70357061  (let* ((*x862-vstack* *x862-vstack*)
    70367062         (*x862-top-vstack-lcell* *x862-top-vstack-lcell*))
    7037     (let* ((nreg (x862-one-untargeted-reg-form seg n x8664::arg_z)))
     7063    (let* ((nreg (x862-one-untargeted-reg-form seg n *x862-arg-z*)))
    70387064      (unless (acode-fixnum-form-p n)
    70397065        (! trap-unless-fixnum nreg))
    70407066      (x862-vpush-register seg nreg))
    70417067     (x862-multiple-value-body seg form) ; sets nargs
    7042     (! nth-value x8664::arg_z))
    7043   (<- x8664::arg_z)
     7068    (! nth-value *x862-arg-z*))
     7069  (<- *x862-arg-z*)
    70447070  (^))
    70457071
     
    70687094  (with-x86-local-vinsn-macros (seg vreg xfer)
    70697095    (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    7070       (! compare-u8-constant (x862-one-untargeted-reg-form seg form x8664::arg_z)
     7096      (! compare-u8-constant (x862-one-untargeted-reg-form seg form *x862-arg-z*)
    70717097         (target-arch-case
    70727098          (:x8664 x8664::subtag-character)))
     
    71597185         vreg
    71607186         xfer
    7161          (x862-one-untargeted-reg-form seg form x8664::arg_z)
     7187         (x862-one-untargeted-reg-form seg form *x862-arg-z*)
    71627188         cr-bit
    71637189         true-p)))))
     
    71867212          (if initval
    71877213            (progn
    7188               (x862-three-targeted-reg-forms seg element-count ($ x8664::arg_x) st ($ x8664::arg_y) initval ($ x8664::arg_z))
     7214              (x862-three-targeted-reg-forms seg element-count ($ x8664::arg_x) st ($ *x862-arg-y*) initval ($ *x862-arg-z*))
    71897215              (! misc-alloc-init)
    7190               (<- ($ x8664::arg_z)))
     7216              (<- ($ *x862-arg-z*)))
    71917217            (progn
    7192               (x862-two-targeted-reg-forms seg element-count ($ x8664::arg_y) st ($ x8664::arg_z))
     7218              (x862-two-targeted-reg-forms seg element-count ($ *x862-arg-y*) st ($ *x862-arg-z*))
    71937219              (! misc-alloc)
    7194               (<- ($ x8664::arg_z))))))
     7220              (<- ($ *x862-arg-z*))))))
    71957221        (^))))
    71967222
     
    72067232        (if count
    72077233          (! %iasr-c target (if (> count max) max count)
    7208              (x862-one-untargeted-reg-form seg form2 x8664::arg_z))
    7209           (multiple-value-bind (cnt src) (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z))
     7234             (x862-one-untargeted-reg-form seg form2 *x862-arg-z*))
     7235          (multiple-value-bind (cnt src) (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*))
    72107236            (! %iasr target cnt src))))
    72117237      (^))))
     
    72197245      (ensuring-node-target (target vreg)
    72207246        (if count
    7221           (let ((src (x862-one-untargeted-reg-form seg form2 ($ x8664::arg_z))))
     7247          (let ((src (x862-one-untargeted-reg-form seg form2 ($ *x862-arg-z*))))
    72227248            (if (<= count 31)
    72237249              (! %ilsr-c target count src)
    72247250              (!  lri target 0)))
    7225           (multiple-value-bind (cnt src) (x862-two-targeted-reg-forms seg form1 ($ x8664::arg_y) form2 ($ x8664::arg_z))
     7251          (multiple-value-bind (cnt src) (x862-two-targeted-reg-forms seg form1 ($ *x862-arg-y*) form2 ($ *x862-arg-z*))
    72267252            (! %ilsr target cnt src))))
    72277253      (^))))
     
    73277353                   (x862-two-targeted-reg-forms seg
    73287354                                                ptr ptrreg
    7329                                                 offset ($ x8664::arg_z))
    7330                    (! fixnum->signed-natural offsetreg x8664::arg_z)
     7355                                                offset ($ *x862-arg-z*))
     7356                   (! fixnum->signed-natural offsetreg *x862-arg-z*)
    73317357                   (if double-p
    73327358                     (! mem-ref-double-float fp-reg ptrreg offsetreg)
     
    73737399                         (x862-one-untargeted-reg-form seg
    73747400                                                       offset
    7375                                                        x8664::arg_z))
     7401                                                       *x862-arg-z*))
    73767402                        (x862-one-targeted-reg-form seg newval fp-reg)
    7377                         (x862-pop-register seg x8664::arg_z)
     7403                        (x862-pop-register seg *x862-arg-z*)
    73787404                        (x862-pop-register seg ptr-reg)
    7379                         (! fixnum->signed-natural offset-reg x8664::arg_z)
     7405                        (! fixnum->signed-natural offset-reg *x862-arg-z*)
    73807406                        (if double-p
    73817407                          (! mem-set-double-float fp-reg ptr-reg offset-reg)
     
    73847410              (t
    73857411               (cond (immoffset
    7386                       (let* ((rnew ($ x8664::arg_z)))
     7412                      (let* ((rnew ($ *x862-arg-z*)))
    73877413                        (x862-push-register
    73887414                         seg
     
    73987424                            (! mem-set-c-single-float fp-reg ptr-reg fixoffset)))))
    73997425                     (t
    7400                       (let* ((roffset ($ x8664::arg_y))
    7401                              (rnew ($ x8664::arg_z)))
     7426                      (let* ((roffset ($ *x862-arg-y*))
     7427                             (rnew ($ *x862-arg-z*)))
    74027428                        (x862-push-register
    74037429                         seg
     
    74167442                          (! mem-set-double-float fp-reg ptr-reg offset-reg)
    74177443                          (! mem-set-single-float fp-reg ptr-reg offset-reg))))))
    7418                (<- x8664::arg_z)))
     7444               (<- *x862-arg-z*)))
    74197445        (^)))))
    74207446
     
    74497475             (! mem-ref-c-absolute-natural dest absptr)
    74507476             (if offval
    7451                (let* ((src (x862-macptr-arg-to-reg seg ptr ($ x8664::imm0 :mode :address))))
     7477               (let* ((src (x862-macptr-arg-to-reg seg ptr ($ *x862-imm0* :mode :address))))
    74527478                 (! mem-ref-c-natural dest src offval))
    7453                (let* ((src (x862-macptr-arg-to-reg seg ptr ($ x8664::imm0 :mode :address))))
     7479               (let* ((src (x862-macptr-arg-to-reg seg ptr ($ *x862-imm0* :mode :address))))
    74547480                 (if triv-p
    74557481                   (with-imm-temps (src) (x)
    74567482                     (if (acode-fixnum-form-p offset)
    74577483                       (x862-lri seg x (acode-fixnum-form-p offset))
    7458                        (! fixnum->signed-natural x (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7484                       (! fixnum->signed-natural x (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    74597485                     (! mem-ref-natural dest src x))
    74607486                   (progn
    74617487                     (! temp-push-unboxed-word src)
    74627488                     (x862-open-undo $undostkblk)
    7463                      (let* ((oreg (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7489                     (let* ((oreg (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    74647490                       (with-imm-temps () (src x)
    74657491                         (! temp-pop-unboxed-word src)
     
    74857511              (<- dest))))
    74867512        (with-imm-target () (src-reg :address)
    7487           (x862-two-targeted-reg-forms seg ptr src-reg offset ($ x8664::arg_z))
     7513          (x862-two-targeted-reg-forms seg ptr src-reg offset ($ *x862-arg-z*))
    74887514          (if (node-reg-p vreg)
    7489             (! mem-ref-bit-fixnum vreg src-reg ($ x8664::arg_z))
     7515            (! mem-ref-bit-fixnum vreg src-reg ($ *x862-arg-z*))
    74907516            (with-imm-target ()           ;OK if src-reg & dest overlap
    74917517                (dest :u8)
     
    75427568                         (if (acode-fixnum-form-p offset)
    75437569                           (x862-lri seg offset-reg (acode-fixnum-form-p offset))
    7544                            (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7570                           (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    75457571                         (progn
    75467572                           (! temp-push-unboxed-word src-reg)
    75477573                           (x862-open-undo $undostkblk)
    7548                            (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z))
     7574                           (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*))
    75497575                           (! temp-pop-unboxed-word src-reg)
    75507576                           (x862-close-undo)))
     
    75797605                       (if (acode-fixnum-form-p offset)
    75807606                         (x862-lri seg offset-reg (acode-fixnum-form-p offset))
    7581                          (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7607                         (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    75827608                       (progn
    75837609                         (! temp-push-unboxed-word src-reg)
    75847610                         (x862-open-undo $undostkblk)
    7585                          (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z))
     7611                         (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*))
    75867612                         (! temp-pop-unboxed-word src-reg)
    75877613                         (x862-close-undo)))
     
    76237649                       (if (acode-fixnum-form-p offset)
    76247650                         (x862-lri seg offset-reg (acode-fixnum-form-p offset))
    7625                          (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z)))
     7651                         (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*)))
    76267652                       (progn
    76277653                         (! temp-push-unboxed-word src-reg)
    76287654                         (x862-open-undo $undostkblk)
    7629                          (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset x8664::arg_z))
     7655                         (! fixnum->signed-natural offset-reg (x862-one-untargeted-reg-form seg offset *x862-arg-z*))
    76307656                         (! temp-pop-unboxed-word src-reg)
    76317657                         (x862-close-undo)))
     
    76677693                     (%rplaca pair (x862-vloc-ea *x862-vstack*))
    76687694                     (x862-vpush-register seg val :reserved))
    7669                  (x862-vpush-register seg (x862-one-untargeted-reg-form seg val x8664::arg_z) :reserved))
     7695                 (x862-vpush-register seg (x862-one-untargeted-reg-form seg val *x862-arg-z*) :reserved))
    76707696                 (%rplacd pair *x862-top-vstack-lcell*)))
    76717697              (t (x862-seq-bind-var seg var val)
     
    76877713(defx862 x862-closed-function closed-function (seg vreg xfer afunc)
    76887714  (x862-make-closure seg afunc nil)
    7689   (when vreg (<- x8664::arg_z))
     7715  (when vreg (<- *x862-arg-z*))
    76907716  (^))
    76917717
     
    77267752          (dolist (ref fwd-refs)
    77277753            (let ((ea (var-ea (pop ref))))
    7728               (x862-addrspec-to-reg seg ea x8664::temp0)
     7754              (x862-addrspec-to-reg seg ea *x862-temp0*)
    77297755              (dolist (r ref)
    77307756                (let* ((v-ea (var-ea (cdr r))))
    77317757                  (let* ((val-reg (if (eq v-ea ea)
    7732                                     x8664::temp0
     7758                                    *x862-temp0*
    77337759                                    (progn
    7734                                       (x862-addrspec-to-reg seg v-ea x8664::temp1)
    7735                                       x8664::temp1))))
    7736                     (! set-closure-forward-reference val-reg x8664::temp0 (car r)))))))
     7760                                      (x862-addrspec-to-reg seg v-ea *x862-temp1*)
     7761                                      *x862-temp1*))))
     7762                    (! set-closure-forward-reference val-reg *x862-temp0* (car r)))))))
    77377763          (x862-undo-body seg vreg xfer body old-stack)
    77387764          (dolist (var real-vars)
     
    77817807            (x862-form
    77827808             seg
    7783              (if need-break (if dest-vd x8664::arg_z) dest-vd)
     7809             (if need-break (if dest-vd *x862-arg-z*) dest-vd)
    77847810             (if need-break nil dest-cd)
    77857811             value)
    77867812            (when need-break
    77877813              (x862-unwind-set seg dest-cd dest-stack)
    7788               (when dest-vd (x862-copy-register seg dest-vd x8664::arg_z))
     7814              (when dest-vd (x862-copy-register seg dest-vd *x862-arg-z*))
    77897815              (x862-branch seg dest-cd))))))
    77907816    (x862-unreachable-store)))
     
    78067832           (ensuring-node-target (target vreg)
    78077833             (! lisp-word-ref-c target
    7808                 (x862-one-untargeted-reg-form seg base x8664::arg_z)
     7834                (x862-one-untargeted-reg-form seg base *x862-arg-z*)
    78097835                (ash fixoffset *x862-target-fixnum-shift*)))
    78107836           (^))
    78117837          (t (multiple-value-bind (breg oreg)
    7812                                   (x862-two-untargeted-reg-forms seg base x8664::arg_y offset x8664::arg_z)
     7838                                  (x862-two-untargeted-reg-forms seg base *x862-arg-y* offset *x862-arg-z*)
    78137839               (ensuring-node-target (target vreg)
    78147840                 (! lisp-word-ref target breg oreg))
     
    78237849           (ensuring-node-target (target vreg)
    78247850             (! lisp-word-ref-c target
    7825                 (x862-one-untargeted-reg-form seg base x8664::arg_z)
     7851                (x862-one-untargeted-reg-form seg base *x862-arg-z*)
    78267852                fixoffset))
    78277853           (^))
    78287854          (t (multiple-value-bind (breg oreg)
    7829                                   (x862-two-untargeted-reg-forms seg base x8664::arg_y offset x8664::arg_z)
     7855                                  (x862-two-untargeted-reg-forms seg base *x862-arg-y* offset *x862-arg-z*)
    78307856               (with-imm-target () (otemp :s32)
    78317857                 (! fixnum->signed-natural otemp oreg)
     
    78427868           (with-imm-target () (val :natural)
    78437869             (! lisp-word-ref-c val
    7844                 (x862-one-untargeted-reg-form seg base x8664::arg_z)
     7870                (x862-one-untargeted-reg-form seg base *x862-arg-z*)
    78457871                fixoffset)
    78467872             (<- val))
    78477873           (^))
    78487874          (t (multiple-value-bind (breg oreg)
    7849                  (x862-two-untargeted-reg-forms seg base x8664::arg_y offset x8664::arg_z)
     7875                 (x862-two-untargeted-reg-forms seg base *x862-arg-y* offset *x862-arg-z*)
    78507876               (with-imm-target () (otemp :s32)
    78517877                 (! fixnum->signed-natural otemp oreg)
     
    78577883(defx862 x862-int>0-p int>0-p (seg vreg xfer cc form)
    78587884  (multiple-value-bind (cr-bit true-p) (acode-condition-to-x86-cr-bit cc)
    7859     (x862-one-targeted-reg-form seg form ($ x8664::arg_z))
     7885    (x862-one-targeted-reg-form seg form ($ *x862-arg-z*))
    78607886    (! integer-sign)
    7861     (x862-test-reg-%izerop seg vreg xfer x8664::imm0 cr-bit true-p 0)))
     7887    (x862-test-reg-%izerop seg vreg xfer *x862-imm0* cr-bit true-p 0)))
    78627888
    78637889
     
    78667892  (let* ((*x862-vstack* *x862-vstack*)
    78677893         (*x862-top-vstack-lcell* *x862-top-vstack-lcell*))
    7868     (x862-vpush-register seg (x862-one-untargeted-reg-form seg tag x8664::arg_z))
     7894    (x862-vpush-register seg (x862-one-untargeted-reg-form seg tag *x862-arg-z*))
    78697895    (if (x862-trivial-p valform)
    78707896      (progn
    7871         (x862-vpush-register seg (x862-one-untargeted-reg-form seg valform x8664::arg_z))
     7897        (x862-vpush-register seg (x862-one-untargeted-reg-form seg valform *x862-arg-z*))
    78727898        (x862-set-nargs seg 1))
    78737899      (x862-multiple-value-body seg valform))
     
    78857911         (tag-label-value (aref *backend-labels* tag-label))
    78867912         (mv-pass (x862-mv-p xfer)))
    7887     (x862-one-targeted-reg-form seg tag ($ x8664::arg_z))
     7913    (x862-one-targeted-reg-form seg tag ($ *x862-arg-z*))
    78887914    (if mv-pass
    78897915      (! nmkcatchmv tag-label-value)
     
    78927918    (if mv-pass
    78937919      (x862-multiple-value-body seg valform) 
    7894       (x862-one-targeted-reg-form seg valform ($ x8664::arg_z)))
    7895     (x862-lri seg x8664::imm0 (ash 1 *x862-target-fixnum-shift*))
     7920      (x862-one-targeted-reg-form seg valform ($ *x862-arg-z*)))
     7921    (x862-lri seg *x862-imm0* (ash 1 *x862-target-fixnum-shift*))
    78967922    (if mv-pass
    78977923      (! nthrowvalues tag-label-value)
     
    78997925    (x862-close-undo)
    79007926    (@= tag-label)
    7901     (unless mv-pass (if vreg (<- x8664::arg_z)))
     7927    (unless mv-pass (if vreg (<- *x862-arg-z*)))
    79027928    (let* ((*x862-returning-values* mv-pass)) ; nlexit keeps values on stack
    79037929      (^))))
     
    79527978           (x862-three-targeted-reg-forms seg
    79537979                                          arr ($ x8664::arg_x)
    7954                                           i ($ x8664::arg_y)
    7955                                           j ($ x8664::arg_z))
     7980                                          i ($ *x862-arg-y*)
     7981                                          j ($ *x862-arg-z*))
    79567982           (x862-fixed-call-builtin seg vreg xfer nil (subprim-name->offset '.SParef2))))))
    79577983
     
    80068032          (t
    80078033           (x862-four-targeted-reg-forms seg
    8008                                          arr ($ x8664::temp0)
     8034                                         arr ($ *x862-temp0*)
    80098035                                         i ($ x8664::arg_x)
    8010                                          j ($ x8664::arg_y)
    8011                                          k ($ x8664::arg_z))
     8036                                         j ($ *x862-arg-y*)
     8037                                         k ($ *x862-arg-z*))
    80128038           (x862-fixed-call-builtin seg vreg xfer nil (subprim-name->offset '.SParef3))))))
    80138039                                         
     
    80438069          (t
    80448070           (x862-four-targeted-reg-forms seg
    8045                                          arr ($ x8664::temp0)
     8071                                         arr ($ *x862-temp0*)
    80468072                                         i ($ x8664::arg_x)
    8047                                          j ($ x8664::arg_y)
    8048                                          new ($ x8664::arg_z))
     8073                                         j ($ *x862-arg-y*)
     8074                                         new ($ *x862-arg-z*))
    80498075           (x862-fixed-call-builtin seg vreg xfer nil (subprim-name->offset '.SPaset2))))))
    80508076
     
    80828108                         (if (typep dim2 'fixnum) dim2))))
    80838109          (t
    8084            (x862-push-register seg (x862-one-untargeted-reg-form seg arr ($ x8664::arg_z)))
     8110           (x862-push-register seg (x862-one-untargeted-reg-form seg arr ($ *x862-arg-z*)))
    80858111           (x862-four-targeted-reg-forms seg
    8086                                          i ($ x8664::temp0)
     8112                                         i ($ *x862-temp0*)
    80878113                                         j ($ x8664::arg_x)
    8088                                          k ($ x8664::arg_y)
    8089                                          new ($ x8664::arg_z))
     8114                                         k ($ *x862-arg-y*)
     8115                                         new ($ *x862-arg-z*))
    80908116           (x862-pop-register seg ($ x8664::temp1))
    80918117           (x862-fixed-call-builtin seg vreg xfer nil (subprim-name->offset '.SPaset3))))))
     
    81198145      (x862-vref seg vreg xfer type-keyword uvector index (unless *x862-reckless* (nx-lookup-target-uvector-subtag type-keyword)))
    81208146      (progn
    8121         (x862-three-targeted-reg-forms seg subtag ($ x8664::arg_x) uvector ($ x8664::arg_y) index ($ x8664::arg_z))
     8147        (x862-three-targeted-reg-forms seg subtag ($ x8664::arg_x) uvector ($ *x862-arg-y*) index ($ *x862-arg-z*))
    81228148        (! subtag-misc-ref)
    8123         (when vreg (<- ($ x8664::arg_z)))
     8149        (when vreg (<- ($ *x862-arg-z*)))
    81248150        (^)) )))
    81258151
     
    81338159      (x862-vset seg vreg xfer type-keyword uvector index newval (unless *x862-reckless* (nx-lookup-target-uvector-subtag type-keyword)))
    81348160      (progn
    8135         (x862-four-targeted-reg-forms seg subtag ($ x8664::temp0) uvector ($ x8664::arg_x) index ($ x8664::arg_y) newval ($ x8664::arg_z))
     8161        (x862-four-targeted-reg-forms seg subtag ($ x8664::temp0) uvector ($ x8664::arg_x) index ($ *x862-arg-y*) newval ($ *x862-arg-z*))
    81368162        (! subtag-misc-set)
    8137         (when vreg (<- ($ x8664::arg_z)))
     8163        (when vreg (<- ($ *x862-arg-z*)))
    81388164        (^)))))
    81398165
     
    81788204  (when vreg
    81798205    (let* ((symreg (x862-one-untargeted-reg-form seg (make-acode (%nx1-operator immediate)
    8180                                                                  (x862-symbol-entry-locative sym)) x8664::arg_z)))
     8206                                                                 (x862-symbol-entry-locative sym)) *x862-arg-z*)))
    81818207      (with-node-temps (vreg symreg) (val)
    81828208        (! symbol-function val symreg)
     
    82328258              (x862-open-undo $undostkblk))
    82338259            (! list))
    8234           (x862-vpush-register seg x8664::arg_z))
     8260          (x862-vpush-register seg *x862-arg-z*))
    82358261        (when rest (x862-bind-var seg rest restloc))
    82368262        (destructuring-bind (vars inits) auxen
     
    82548280                         seg
    82558281                         val
    8256                          (if (eq vreg x8664::arg_z) x8664::arg_y x8664::arg_z))))
     8282                         (if (eq vreg *x862-arg-z*) *x862-arg-y* *x862-arg-z*))))
    82578283          (! ,vinsn val-reg)
    82588284          (when vreg (<- val-reg))
     
    83148340          (x862-form seg vreg xfer form)
    83158341          (let* ((ok (backend-get-next-label)))
    8316             (x862-one-targeted-reg-form seg form ($ x8664::arg_y))
    8317             (x862-store-immediate seg typespec ($ x8664::arg_z))
     8342            (x862-one-targeted-reg-form seg form ($ *x862-arg-y*))
     8343            (x862-store-immediate seg typespec ($ *x862-arg-z*))
    83188344            (x862-store-immediate seg 'typep ($ x8664::fname))
    83198345            (x862-set-nargs seg 2)
    8320             (x862-vpush-register seg ($ x8664::arg_y))
    8321             (! call-known-symbol ($ x8664::arg_z))
    8322             (! compare-to-nil ($ x8664::arg_z))
    8323             (x862-vpop-register seg ($ x8664::arg_y))
     8346            (x862-vpush-register seg ($ *x862-arg-y*))
     8347            (! call-known-symbol ($ *x862-arg-z*))
     8348            (! compare-to-nil ($ *x862-arg-z*))
     8349            (x862-vpop-register seg ($ *x862-arg-y*))
    83248350            (! cbranch-false (aref *backend-labels* ok) x86::x86-e-bits)
    83258351            (x862-lri seg ($ x8664::arg_x) (ash $XWRONGTYPE *x862-target-fixnum-shift*))
    8326             (x862-store-immediate seg typespec ($ x8664::arg_z))
     8352            (x862-store-immediate seg typespec ($ *x862-arg-z*))
    83278353            (x862-set-nargs seg 3)
    83288354            (! ksignalerr)
    83298355            (@ ok)
    8330             (<- ($ x8664::arg_y))
     8356            (<- ($ *x862-arg-y*))
    83318357            (^)))))))
    83328358         
     
    83378363
    83388364(defx862 x862-%badarg2 %badarg2 (seg vreg xfer badthing goodthing)
    8339   (x862-two-targeted-reg-forms seg badthing ($ x8664::arg_y) goodthing ($ x8664::arg_z))
     8365  (x862-two-targeted-reg-forms seg badthing ($ *x862-arg-y*) goodthing ($ *x862-arg-z*))
    83408366  (x862-lri seg ($ x8664::arg_x) (ash $XWRONGTYPE *x862-target-fixnum-shift*))
    83418367  (x862-set-nargs seg 3)
     
    83698395
    83708396(defx862 x862-setq-free setq-free (seg vreg xfer sym val)
    8371   (let* ((rsym ($ x8664::arg_y))
    8372          (rval ($ x8664::arg_z)))
     8397  (let* ((rsym ($ *x862-arg-y*))
     8398         (rval ($ *x862-arg-z*)))
    83738399    (x862-one-targeted-reg-form seg val rval)
    83748400    (x862-immediate seg rsym nil (x862-symbol-value-cell sym))
     
    83788404
    83798405(defx862 x862-%setf-macptr %setf-macptr (seg vreg xfer x y)
    8380   (x862-vpush-register seg (x862-one-untargeted-reg-form seg x x8664::arg_z))
     8406  (x862-vpush-register seg (x862-one-untargeted-reg-form seg x *x862-arg-z*))
    83818407  (with-imm-target () (src-reg :address)
    83828408    (x862-one-targeted-reg-form seg y src-reg)
    8383     (x862-vpop-register seg x8664::arg_z)
     8409    (x862-vpop-register seg *x862-arg-z*)
    83848410    (unless (or *x862-reckless* (x862-form-typep x 'macptr))
    83858411      (with-imm-temps (src-reg) ()
    8386         (! trap-unless-macptr x8664::arg_z)))
    8387     (! set-macptr-address src-reg x8664::arg_z)
    8388     (<- x8664::arg_z)
     8412        (! trap-unless-macptr *x862-arg-z*)))
     8413    (! set-macptr-address src-reg *x862-arg-z*)
     8414    (<- *x862-arg-z*)
    83898415    (^)))
    83908416
    83918417(defx862 x862-%setf-double-float %setf-double-float (seg vref xfer fnode fval)
    8392   (x862-vpush-register seg (x862-one-untargeted-reg-form seg fnode x8664::arg_z))
    8393   (let* ((target ($ x8664::fp1 :class :fpr :mode :double-float))
    8394          (node ($ x8664::arg_z)))
     8418  (x862-vpush-register seg (x862-one-untargeted-reg-form seg fnode *x862-arg-z*))
     8419  (let* ((target ($ *x862-fp1* :class :fpr :mode :double-float))
     8420         (node ($ *x862-arg-z*)))
    83958421    (x862-one-targeted-reg-form seg fval target)
    83968422    (x862-vpop-register seg node)
     
    84388464         (protform-label (backend-get-next-label))
    84398465         (old-stack (x862-encode-stack)))
    8440     (x862-two-targeted-reg-forms seg symbols ($ x8664::arg_y) values ($ x8664::arg_z))
     8466    (x862-two-targeted-reg-forms seg symbols ($ *x862-arg-y*) values ($ *x862-arg-z*))
    84418467    (! progvsave)
    84428468    (x862-open-undo $undostkblk)
     
    84948520                (x862-form seg vreg nil newval)))
    84958521            (with-imm-target () (src :address)
    8496               (x862-two-targeted-reg-forms seg ptr src newval ($ x8664::arg_z))
    8497               (! mem-set-c-bit-variable-value src offval ($ x8664::arg_z))
    8498               (<- ($ x8664::arg_z)))))
     8522              (x862-two-targeted-reg-forms seg ptr src newval ($ *x862-arg-z*))
     8523              (! mem-set-c-bit-variable-value src offval ($ *x862-arg-z*))
     8524              (<- ($ *x862-arg-z*)))))
    84998525        (if constval
    85008526          (with-imm-target () (src :address)
    8501             (x862-two-targeted-reg-forms seg ptr src offset ($ x8664::arg_z))
     8527            (x862-two-targeted-reg-forms seg ptr src offset ($ *x862-arg-z*))
    85028528            (if (eql constval 0)
    8503               (! mem-set-bit-0 src ($ x8664::arg_z))
    8504               (! mem-set-bit-1 src ($ x8664::arg_z)))
     8529              (! mem-set-bit-0 src ($ *x862-arg-z*))
     8530              (! mem-set-bit-1 src ($ *x862-arg-z*)))
    85058531            (when vreg
    85068532              (x862-form seg vreg nil newval)))
    85078533          (with-imm-target () (src :address)
    8508             (x862-three-targeted-reg-forms seg ptr src offset ($ x8664::arg_y) newval ($ x8664::arg_z))
    8509             (! mem-set-bit-variable-value src ($ x8664::arg_y) ($ x8664::arg_z))
    8510             (<- ($ x8664::arg_z)))))
     8534            (x862-three-targeted-reg-forms seg ptr src offset ($ *x862-arg-y*) newval ($ *x862-arg-z*))
     8535            (! mem-set-bit-variable-value src ($ *x862-arg-y*) ($ *x862-arg-z*))
     8536            (<- ($ *x862-arg-z*)))))
    85118537      (^)))
    85128538
     
    85308556              (unless triv-by
    85318557                (x862-push-register seg ptr-reg))
    8532               (let* ((boxed-by (x862-one-targeted-reg-form seg by x8664::arg_z)))
     8558              (let* ((boxed-by (x862-one-targeted-reg-form seg by *x862-arg-z*)))
    85338559                (unless triv-by
    85348560                  (x862-pop-register seg ptr-reg))
     
    85718597      (setq ngpr-args 0)
    85728598      (unless simple-foreign-args
    8573         (x862-vpush-register seg (x862-one-untargeted-reg-form seg idx x8664::arg_z)))
     8599        (x862-vpush-register seg (x862-one-untargeted-reg-form seg idx *x862-arg-z*)))
    85748600      ;; Evaluate each form into the C frame, according to the
    85758601      ;; matching argspec.
     
    86058631                         (incf other-offset)))))))))     
    86068632      (unless simple-foreign-args
    8607         (x862-vpop-register seg ($ x8664::arg_z)))
     8633        (x862-vpop-register seg ($ *x862-arg-z*)))
    86088634      (! syscall)
    86098635      (x862-close-undo)
     
    86138639               (ensuring-node-target (target vreg)
    86148640                 (! makeu64)
    8615                  (x862-copy-register seg target ($ x8664::arg_z))))
     8641                 (x862-copy-register seg target ($ *x862-arg-z*))))
    86168642              ((eq resultspec :signed-doubleword)
    86178643               (ensuring-node-target (target vreg)
    86188644                 (! makes64)
    8619                  (x862-copy-register seg target ($ x8664::arg_z))))
     8645                 (x862-copy-register seg target ($ *x862-arg-z*))))
    86208646              (t
    86218647               (case resultspec
    8622                  (:signed-byte (! sign-extend-s8 x8664::imm0 x8664::imm0))
    8623                  (:signed-halfword (! sign-extend-s16 x8664::imm0 x8664::imm0))
    8624                  (:signed-fullword (! sign-extend-s32 x8664::imm0 x8664::imm0))
    8625                  (:unsigned-byte (! zero-extend-u8 x8664::imm0 x8664::imm0))
    8626                  (:unsigned-halfword (! zero-extend-u16 x8664::imm0 x8664::imm0))
    8627                  (:unsigned-fullword (! zero-extend-u32 x8664::imm0 x8664::imm0)))               
    8628                (<- (make-wired-lreg x8664::imm0
     8648                 (:signed-byte (! sign-extend-s8 *x862-imm0* *x862-imm0*))
     8649                 (:signed-halfword (! sign-extend-s16 *x862-imm0* *x862-imm0*))
     8650                 (:signed-fullword (! sign-extend-s32 *x862-imm0* *x862-imm0*))
     8651                 (:unsigned-byte (! zero-extend-u8 *x862-imm0* *x862-imm0*))
     8652                 (:unsigned-halfword (! zero-extend-u16 *x862-imm0* *x862-imm0*))
     8653                 (:unsigned-fullword (! zero-extend-u32 *x862-imm0* *x862-imm0*)))               
     8654               (<- (make-wired-lreg *x862-imm0*
    86298655                                    :mode
    86308656                                    (gpr-mode-name-value
     
    88288854
    88298855(defx862 x862-%debug-trap %debug-trap (seg vreg xfer arg)
    8830   (x862-one-targeted-reg-form seg arg ($ x8664::arg_z))
     8856  (x862-one-targeted-reg-form seg arg ($ *x862-arg-z*))
    88318857  (! %debug-trap)
    8832   (<- ($ x8664::arg_z))
     8858  (<- ($ *x862-arg-z*))
    88338859  (^))
    88348860
     
    88368862  (seg vreg xfer arg)
    88378863  (ensuring-node-target (target vreg)
    8838     (let* ((reg (if (eq (hard-regspec-value target) x8664::arg_z) ($ x8664::arg_y) ($ x8664::arg_z))))
     8864    (let* ((reg (if (eq (hard-regspec-value target) *x862-arg-z*) ($ *x862-arg-y*) ($ *x862-arg-z*))))
    88398865      (x862-one-targeted-reg-form seg arg reg)
    88408866      (! eep.address target reg)))
     
    90059031         (x862-restore-nvrs seg *x862-register-restore-ea* *x862-register-restore-count*)
    90069032         (x862-restore-full-lisp-context seg)
    9007          (! %current-frame-ptr ($ x8664::arg_z))
     9033         (! %current-frame-ptr ($ *x862-arg-z*))
    90089034         (! jump-return-pc))
    90099035        (t
     
    90419067(defx862 x862-with-variable-c-frame with-variable-c-frame (seg vreg xfer size body &aux
    90429068                                                               (old-stack (x862-encode-stack)))
    9043   (let* ((reg (x862-one-untargeted-reg-form seg size x8664::arg_z)))
     9069  (let* ((reg (x862-one-untargeted-reg-form seg size *x862-arg-z*)))
    90449070    (! alloc-variable-c-frame reg)
    90459071    (x862-open-undo $undo-x86-c-frame)
     
    90479073
    90489074(defx862 x862-%symbol->symptr %symbol->symptr (seg vreg xfer sym)
    9049   (let* ((src (x862-one-untargeted-reg-form seg sym x8664::arg_z)))
     9075  (let* ((src (x862-one-untargeted-reg-form seg sym *x862-arg-z*)))
    90509076    (ensuring-node-target (target vreg)
    90519077      (! %symbol->symptr target src))
     
    91109136(defx862 x862-%fixnum-to-single %fixnum-to-single (seg vreg xfer arg)
    91119137  (with-fp-target () (sreg :single-float)
    9112     (let* ((r (x862-one-untargeted-reg-form seg arg x8664::arg_z)))
     9138    (let* ((r (x862-one-untargeted-reg-form seg arg *x862-arg-z*)))
    91139139      (unless (or (acode-fixnum-form-p arg)
    91149140                  *x862-reckless*)
     
    91209146(defx862 x862-%fixnum-to-double %fixnum-to-double (seg vreg xfer arg)
    91219147  (with-fp-target () (dreg :double-float)
    9122     (let* ((r (x862-one-untargeted-reg-form seg arg x8664::arg_z)))
     9148    (let* ((r (x862-one-untargeted-reg-form seg arg *x862-arg-z*)))
    91239149      (unless (or (acode-fixnum-form-p arg)
    91249150                  *x862-reckless*)
Note: See TracChangeset for help on using the changeset viewer.