Index: /trunk/ccl/compiler/PPC/PPC64/ppc64-vinsns.lisp =================================================================== --- /trunk/ccl/compiler/PPC/PPC64/ppc64-vinsns.lisp (revision 376) +++ /trunk/ccl/compiler/PPC/PPC64/ppc64-vinsns.lisp (revision 377) @@ -34,5 +34,5 @@ (define-ppc64-vinsn scale-32bit-misc-index (((dest :u64)) - ((idx :imm) ; A fixnum + ((idx :imm) ; A fixnum ) ()) @@ -41,36 +41,36 @@ (define-ppc64-vinsn scale-16bit-misc-index (((dest :u32)) - ((idx :imm) ; A fixnum - ) - ()) + ((idx :imm) ; A fixnum + ) + ()) (srdi dest idx 2) (addi dest dest ppc64::misc-data-offset)) (define-ppc64-vinsn scale-8bit-misc-index (((dest :u32)) - ((idx :imm) ; A fixnum - ) - ()) + ((idx :imm) ; A fixnum + ) + ()) (srdi dest idx ppc64::word-shift) (addi dest dest ppc64::misc-data-offset)) -(define-ppc64-vinsn scale-64bit-misc-index ((((dest :u64)) - ((idx :imm) ; A fixnum - ) - ())) +(define-ppc64-vinsn scale-64bit-misc-index (((dest :u64)) + ((idx :imm) ; A fixnum + ) + ()) (addi dest idx ppc64::misc-data-offset)) (define-ppc64-vinsn scale-1bit-misc-index (((word-index :u32) - (bitnum :u8)) ; (unsigned-byte 5) - ((idx :imm) ; A fixnum - ) - ) - ; Logically, we want to: - ; 1) Unbox the index by shifting it right 2 bits. - ; 2) Shift (1) right 5 bits - ; 3) Scale (2) by shifting it left 2 bits. - ; We get to do all of this with one instruction + (bitnum :u8)) ; (unsigned-byte 5) + ((idx :imm) ; A fixnum + ) + ) + ; Logically, we want to: + ; 1) Unbox the index by shifting it right 2 bits. + ; 2) Shift (1) right 5 bits + ; 3) Scale (2) by shifting it left 2 bits. + ; We get to do all of this with one instruction (rlwinm word-index idx (- ppc64::nbits-in-word 5) 5 (- ppc64::least-significant-bit ppc64::fixnum-shift)) - (addi word-index word-index ppc64::misc-data-offset) ; Hmmm. Also one instruction, but less impressive somehow. + (addi word-index word-index ppc64::misc-data-offset) ; Hmmm. Also one instruction, but less impressive somehow. (extrwi bitnum idx 5 (- ppc64::nbits-in-word (+ ppc64::fixnum-shift 5)))) @@ -137,7 +137,7 @@ (define-ppc64-vinsn misc-ref-c-single-float (((dest :single-float)) - ((v :lisp) - (idx :u32const)) - ()) + ((v :lisp) + (idx :u32const)) + ()) (lfs dest (:apply + ppc64::misc-data-offset (:apply ash idx 2)) v)) @@ -150,23 +150,23 @@ (define-ppc64-vinsn misc-ref-c-double-float (((dest :double-float)) - ((v :lisp) - (idx :u32const)) - ()) + ((v :lisp) + (idx :u32const)) + ()) (lfd dest (:apply + ppc64::misc-dfloat-offset (:apply ash idx 3)) v)) (define-ppc64-vinsn misc-set-c-double-float (((val :double-float)) - ((v :lisp) - (idx :u32const))) + ((v :lisp) + (idx :u32const))) (stfd val (:apply + ppc64::misc-dfloat-offset (:apply ash idx 3)) v)) (define-ppc64-vinsn misc-set-double-float (() - ((val :double-float) - (v :lisp) - (scaled-idx :u32))) + ((val :double-float) + (v :lisp) + (scaled-idx :u32))) (stfdx val v scaled-idx)) (define-ppc64-vinsn misc-set-c-single-float (((val :single-float)) - ((v :lisp) - (idx :u32const))) + ((v :lisp) + (idx :u32const))) (stfs val (:apply + ppc64::misc-data-offset (:apply ash idx 2)) v)) @@ -185,7 +185,7 @@ (define-ppc64-vinsn misc-ref-c-u16 (((dest :u16)) - ((v :lisp) - (idx :u32const)) - ()) + ((v :lisp) + (idx :u32const)) + ()) (lhz dest (:apply + ppc64::misc-data-offset (:apply ash idx 1)) v)) @@ -202,7 +202,7 @@ (define-ppc64-vinsn misc-ref-s16 (((dest :s16)) - ((v :lisp) - (scaled-idx :u32)) - ()) + ((v :lisp) + (scaled-idx :u32)) + ()) (lhax dest v scaled-idx)) @@ -220,7 +220,7 @@ (define-ppc64-vinsn misc-ref-c-u8 (((dest :u8)) - ((v :lisp) - (idx :u32const)) - ()) + ((v :lisp) + (idx :u32const)) + ()) (lbz dest (:apply + ppc64::misc-data-offset idx) v)) @@ -228,5 +228,5 @@ ((v :lisp) (idx :u32const)) - ()) + ()) (stb val (:apply + ppc64::misc-data-offset idx) v)) @@ -247,5 +247,5 @@ ((v :lisp) (idx :u32const)) - ()) + ()) (lbz dest (:apply + ppc64::misc-data-offset idx) v) (extsb dest dest)) @@ -260,7 +260,7 @@ (define-ppc64-vinsn misc-ref-c-bit-fixnum (((dest :imm)) - ((v :lisp) - (idx :u32const)) - ((temp :u32))) + ((v :lisp) + (idx :u32const)) + ((temp :u32))) (lwz temp (:apply + ppc64::misc-data-offset (:apply ash idx -5)) v) (rlwinm dest @@ -302,6 +302,6 @@ (define-ppc64-vinsn misc-element-count-fixnum (((dest :imm)) - ((v :lisp)) - ((temp :u32))) + ((v :lisp)) + ((temp :u32))) (ld temp ppc64::misc-header-offset v) (rlwinm dest @@ -312,20 +312,17 @@ (define-ppc64-vinsn check-misc-bound (() - ((idx :imm) - (v :lisp)) - ((temp :u32))) - (lwz temp ppc64::misc-header-offset v) - (rlwinm temp - temp - (- ppc64::nbits-in-word (- ppc64::num-subtag-bits ppc64::fixnumshift)) - (- ppc64::num-subtag-bits ppc64::fixnumshift) - (- ppc64::least-significant-bit ppc64::fixnumshift)) - (twlge idx temp)) + ((idx :imm) + (v :lisp)) + ((temp :u32))) + (ld temp ppc64::misc-header-offset v) + (rldicr temp temp 0 (- 63 8)) + (rldicl temp temp (- 64 (- 8 ppc64::fixnumshift)) (- 8 ppc64::fixnumshift)) + (tdlge idx temp)) (define-ppc64-vinsn 2d-unscaled-index (((dest :u32)) - ((array :lisp) - (i :imm) - (j :imm) - (dim1 :u32))) + ((array :lisp) + (i :imm) + (j :imm) + (dim1 :u32))) (mullw dest i dim1) (add dest dest j)) @@ -334,8 +331,8 @@ (define-ppc64-vinsn 2d-32-scaled-index (((dest :u32)) - ((array :lisp) - (i :imm) - (j :imm) - (dim1 :u32))) + ((array :lisp) + (i :imm) + (j :imm) + (dim1 :u32))) (mullw dest i dim1) (add dest dest j) @@ -343,36 +340,36 @@ (define-ppc64-vinsn 2d-dim1 (((dest :u32)) - ((header :lisp))) - (lwz dest (+ ppc64::misc-data-offset (* 4 (1+ ppc64::arrayH.dim0-cell))) header) - (srawi dest dest ppc64::fixnumshift)) + ((header :lisp))) + (ld dest (+ ppc64::misc-data-offset (* 8 (1+ ppc64::arrayH.dim0-cell))) header) + (sradi dest dest ppc64::fixnumshift)) ;; Return dim1 (unboxed) -(define-ppc64-vinsn check-2d-bound (((dim :u32)) - ((i :imm) - (j :imm) - (header :lisp))) - (lwz dim (+ ppc64::misc-data-offset (* 4 ppc64::arrayH.dim0-cell)) header) - (twlge i dim) - (lwz dim (+ ppc64::misc-data-offset (* 4 (1+ ppc64::arrayH.dim0-cell))) header) - (twlge j dim) - (srawi dim dim ppc64::fixnumshift)) +(define-ppc64-vinsn check-2d-bound (((dim :u64)) + ((i :imm) + (j :imm) + (header :lisp))) + (ld dim (+ ppc64::misc-data-offset (* 8 ppc64::arrayH.dim0-cell)) header) + (tdlge i dim) + (ld dim (+ ppc64::misc-data-offset (* 8 (1+ ppc64::arrayH.dim0-cell))) header) + (tdlge j dim) + (sradi dim dim ppc64::fixnumshift)) (define-ppc64-vinsn array-data-vector-ref (((dest :lisp)) - ((header :lisp))) - (lwz dest ppc64::arrayH.data-vector header)) + ((header :lisp))) + (ld dest ppc64::arrayH.data-vector header)) (define-ppc64-vinsn check-arrayH-rank (() - ((header :lisp) - (expected :u32const)) - ((rank :imm))) + ((header :lisp) + (expected :u32const)) + ((rank :imm))) (lwz rank ppc64::arrayH.rank header) - (twi 27 rank (:apply ash expected ppc64::fixnumshift))) + (tdi 27 rank (:apply ash expected ppc64::fixnumshift))) (define-ppc64-vinsn check-arrayH-flags (() - ((header :lisp) - (expected :u16const)) - ((flags :imm) - (xreg :u32))) + ((header :lisp) + (expected :u16const)) + ((flags :imm) + (xreg :u32))) (lis xreg (:apply ldb (byte 16 16) (:apply ash expected ppc64::fixnumshift))) (ori xreg xreg (:apply ldb (byte 16 0) (:apply ash expected ppc64::fixnumshift))) @@ -410,66 +407,66 @@ (define-ppc64-vinsn mem-ref-c-u16 (((dest :u16)) - ((src :address) - (index :s16const))) + ((src :address) + (index :s16const))) (lhz dest index src)) (define-ppc64-vinsn mem-ref-u16 (((dest :u16)) - ((src :address) - (index :s32))) + ((src :address) + (index :s32))) (lhzx dest src index)) (define-ppc64-vinsn mem-ref-c-s16 (((dest :s16)) - ((src :address) - (index :s16const))) + ((src :address) + (index :s16const))) (lha dest src index)) (define-ppc64-vinsn mem-ref-s16 (((dest :s16)) - ((src :address) - (index :s32))) + ((src :address) + (index :s32))) (lhax dest src index)) (define-ppc64-vinsn mem-ref-c-u8 (((dest :u8)) - ((src :address) - (index :s16const))) + ((src :address) + (index :s16const))) (lbz dest index src)) (define-ppc64-vinsn mem-ref-u8 (((dest :u8)) - ((src :address) - (index :s32))) + ((src :address) + (index :s32))) (lbzx dest src index)) (define-ppc64-vinsn mem-ref-c-s8 (((dest :s8)) - ((src :address) - (index :s16const))) + ((src :address) + (index :s16const))) (lbz dest index src) (extsb dest dest)) (define-ppc64-vinsn mem-ref-s8 (((dest :s8)) - ((src :address) - (index :s32))) + ((src :address) + (index :s32))) (lbzx dest src index) (extsb dest dest)) (define-ppc64-vinsn mem-ref-c-bit (((dest :u8)) - ((src :address) - (byte-index :s16const) - (bit-shift :u8const))) + ((src :address) + (byte-index :s16const) + (bit-shift :u8const))) (lbz dest byte-index src) (rlwinm dest dest bit-shift 31 31)) (define-ppc64-vinsn mem-ref-c-bit-fixnum (((dest :lisp)) - ((src :address) - (byte-index :s16const) - (bit-shift :u8const)) - ((byteval :u8))) + ((src :address) + (byte-index :s16const) + (bit-shift :u8const)) + ((byteval :u8))) (lbz byteval byte-index src) (rlwinm dest byteval bit-shift 29 29)) (define-ppc64-vinsn mem-ref-bit (((dest :u8)) - ((src :address) - (bit-index :lisp)) - ((byte-index :s16) - (bit-shift :u8))) + ((src :address) + (bit-index :lisp)) + ((byte-index :s16) + (bit-shift :u8))) (srwi byte-index bit-index (+ ppc64::fixnumshift 3)) (extrwi bit-shift bit-index 3 27) @@ -480,8 +477,8 @@ (define-ppc64-vinsn mem-ref-bit-fixnum (((dest :lisp)) - ((src :address) - (bit-index :lisp)) - ((byte-index :s16) - (bit-shift :u8))) + ((src :address) + (bit-index :lisp)) + ((byte-index :s16) + (bit-shift :u8))) (srwi byte-index bit-index (+ ppc64::fixnumshift 3)) (extrwi bit-shift bit-index 3 27) @@ -495,90 +492,90 @@ (define-ppc64-vinsn mem-ref-c-double-float (((dest :double-float)) - ((src :address) - (index :s16const))) + ((src :address) + (index :s16const))) (lfd dest index src)) (define-ppc64-vinsn mem-ref-double-float (((dest :double-float)) - ((src :address) - (index :s32))) + ((src :address) + (index :s32))) (lfdx dest src index)) (define-ppc64-vinsn mem-set-c-double-float (() - ((val :double-float) - (src :address) - (index :s16const))) + ((val :double-float) + (src :address) + (index :s16const))) (stfd val index src)) (define-ppc64-vinsn mem-set-double-float (() - ((val :double-float) - (src :address) - (index :s32))) + ((val :double-float) + (src :address) + (index :s32))) (stfdx val src index)) (define-ppc64-vinsn mem-ref-c-single-float (((dest :single-float)) - ((src :address) - (index :s16const))) + ((src :address) + (index :s16const))) (lfs dest index src)) (define-ppc64-vinsn mem-ref-single-float (((dest :single-float)) - ((src :address) - (index :s32))) + ((src :address) + (index :s32))) (lfsx dest src index)) (define-ppc64-vinsn mem-set-c-single-float (() - ((val :single-float) - (src :address) - (index :s16const))) + ((val :single-float) + (src :address) + (index :s16const))) (stfs val index src)) (define-ppc64-vinsn mem-set-single-float (() - ((val :single-float) - (src :address) - (index :s32))) + ((val :single-float) + (src :address) + (index :s32))) (stfsx val src index)) (define-ppc64-vinsn mem-set-c-fullword (() - ((val :u32) - (src :address) - (index :s16const))) + ((val :u32) + (src :address) + (index :s16const))) (stw val index src)) (define-ppc64-vinsn mem-set-fullword (() - ((val :u32) - (src :address) - (index :s32))) + ((val :u32) + (src :address) + (index :s32))) (stwx val src index)) (define-ppc64-vinsn mem-set-c-halfword (() - ((val :u16) - (src :address) - (index :s16const))) + ((val :u16) + (src :address) + (index :s16const))) (sth val index src)) (define-ppc64-vinsn mem-set-halfword (() - ((val :u16) - (src :address) - (index :s32))) + ((val :u16) + (src :address) + (index :s32))) (sthx val src index)) (define-ppc64-vinsn mem-set-c-byte (() - ((val :u16) - (src :address) - (index :s16const))) + ((val :u16) + (src :address) + (index :s16const))) (stb val index src)) (define-ppc64-vinsn mem-set-byte (() - ((val :u8) - (src :address) - (index :s32))) + ((val :u8) + (src :address) + (index :s32))) (stbx val src index)) (define-ppc64-vinsn mem-set-c-bit-0 (() - ((src :address) - (byte-index :s16const) - (mask-begin :u8const) - (mask-end :u8const)) - ((val :u8))) + ((src :address) + (byte-index :s16const) + (mask-begin :u8const) + (mask-end :u8const)) + ((val :u8))) (lbz val byte-index src) (rlwinm val val 0 mask-begin mask-end) @@ -586,8 +583,8 @@ (define-ppc64-vinsn mem-set-c-bit-1 (() - ((src :address) - (byte-index :s16const) - (mask :u8const)) - ((val :u8))) + ((src :address) + (byte-index :s16const) + (mask :u8const)) + ((val :u8))) (lbz val byte-index src) (ori val val mask) @@ -595,9 +592,9 @@ (define-ppc64-vinsn mem-set-c-bit (() - ((src :address) - (byte-index :s16const) - (bit-index :u8const) - (val :imm)) - ((byteval :u8))) + ((src :address) + (byte-index :s16const) + (bit-index :u8const) + (val :imm)) + ((byteval :u8))) (lbz byteval byte-index src) (rlwimi byteval val (:apply logand 31 (:apply - 29 bit-index)) bit-index bit-index) @@ -607,11 +604,11 @@ ;;; long it takes ... (define-ppc64-vinsn mem-set-bit (() - ((src :address) - (bit-index :lisp) - (val :lisp)) - ((bit-shift :u32) - (mask :u32) - (byte-index :u32) - (crf :crf))) + ((src :address) + (bit-index :lisp) + (val :lisp)) + ((bit-shift :u32) + (mask :u32) + (byte-index :u32) + (crf :crf))) (cmplwi crf val (ash 1 ppc64::fixnumshift)) (extrwi bit-shift bit-index 3 27) @@ -635,10 +632,10 @@ (define-ppc64-vinsn extract-tag (((tag :u8)) - ((object :lisp)) - ()) + ((object :lisp)) + ()) (clrlwi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits))) (define-ppc64-vinsn extract-tag-fixnum (((tag :imm)) - ((object :lisp))) + ((object :lisp))) (rlwinm tag object @@ -649,11 +646,11 @@ (define-ppc64-vinsn extract-fulltag (((tag :u8)) - ((object :lisp)) - ()) + ((object :lisp)) + ()) (clrlwi tag object (- ppc64::nbits-in-word ppc64::ntagbits))) (define-ppc64-vinsn extract-fulltag-fixnum (((tag :imm)) - ((object :lisp))) + ((object :lisp))) (rlwinm tag object @@ -664,8 +661,9 @@ (define-ppc64-vinsn extract-typecode (((code :u8)) - ((object :lisp)) - ((crf :crf))) - (clrlwi code object (- ppc64::nbits-in-word ppc64::nlisptagbits)) - (cmpwi crf code ppc64::tag-misc) + ((object :lisp)) + ((crf :crf))) + (clrldi code object (- ppc64::nbits-in-word ppc64::ntagbits)) + (cmpdi crf code ppc64::fulltag-misc) + (clrldi code code (- ppc64::nbits-in-word ppc64::nlisptagbits)) (bne crf :not-misc) (lbz code ppc64::misc-subtag-offset object) @@ -673,6 +671,6 @@ (define-ppc64-vinsn extract-typecode-fixnum (((code :imm)) - ((object (:lisp (:ne code)))) - ((crf :crf) (subtag :u8))) + ((object (:lisp (:ne code)))) + ((crf :crf) (subtag :u8))) (rlwinm code object @@ -681,5 +679,5 @@ (+ ppc64::nlisptagbits ppc64::fixnum-shift)) (- ppc64::least-significant-bit ppc64::fixnum-shift)) - (cmpwi crf code (ash ppc64::tag-misc ppc64::fixnum-shift)) + (cmpwi crf code (ash ppc64::fulltag-misc ppc64::fixnum-shift)) (bne crf :not-misc) (lbz subtag ppc64::misc-subtag-offset object) @@ -689,9 +687,9 @@ (define-ppc64-vinsn require-fixnum (() - ((object :lisp)) - ((crf0 (:crf 0)) - (tag :u8))) + ((object :lisp)) + ((crf0 (:crf 0)) + (tag :u8))) :again - (clrlwi. tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) + (clrldi. tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) (beq+ crf0 :got-it) (uuo_intcerr arch::error-object-not-fixnum object) @@ -700,11 +698,11 @@ (define-ppc64-vinsn require-integer (() - ((object :lisp)) - ((crf0 (:crf 0)) - (tag :u8))) + ((object :lisp)) + ((crf0 (:crf 0)) + (tag :u8))) :again - (clrlwi. tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) + (clrldi. tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) (beq+ crf0 :got-it) - (cmpwi crf0 tag ppc64::tag-misc) + (cmpwi crf0 tag ppc64::fulltag-misc) (bne crf0 :no-got) (lbz tag ppc64::misc-subtag-offset object) @@ -717,10 +715,10 @@ (define-ppc64-vinsn require-simple-vector (() - ((object :lisp)) - ((tag :u8) - (crf :crf))) + ((object :lisp)) + ((tag :u8) + (crf :crf))) :again (clrlwi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) - (cmpwi crf tag ppc64::tag-misc) + (cmpwi crf tag ppc64::fulltag-misc) (bne crf :no-got) (lbz tag ppc64::misc-subtag-offset object) @@ -733,17 +731,15 @@ (define-ppc64-vinsn require-simple-string (() - ((object :lisp)) - ((tag :u8) - (crf :crf) - (crf2 :crf))) + ((object :lisp)) + ((tag :u8) + (crf :crf) + (crf2 :crf))) :again (clrlwi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) - (cmpwi crf tag ppc64::tag-misc) + (cmpwi crf tag ppc64::fulltag-misc) (bne crf :no-got) (lbz tag ppc64::misc-subtag-offset object) (cmpwi crf tag ppc64::subtag-simple-base-string) - (cmpwi crf2 tag ppc64::subtag-simple-general-string) (beq+ crf :got-it) - (beq+ crf2 :got-it) :no-got (uuo_intcerr arch::error-object-not-simple-string object) @@ -751,13 +747,14 @@ :got-it) - + +#+notyet (define-ppc64-vinsn require-real (() - ((object :lisp)) - ((crf0 (:crf 0)) - (tag :u8))) + ((object :lisp)) + ((crf0 (:crf 0)) + (tag :u8))) :again (clrlwi. tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) (beq+ crf0 :got-it) - (cmpwi crf0 tag ppc64::tag-misc) + (cmpwi crf0 tag ppc64::fulltag-misc) (bne crf0 :no-got) (lbz tag ppc64::misc-subtag-offset object) @@ -769,12 +766,13 @@ :got-it) +#+notyet (define-ppc64-vinsn require-number (() - ((object :lisp)) - ((crf0 (:crf 0)) - (tag :u8))) + ((object :lisp)) + ((crf0 (:crf 0)) + (tag :u8))) :again (clrlwi. tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) (beq+ crf0 :got-it) - (cmpwi crf0 tag ppc64::tag-misc) + (cmpwi crf0 tag ppc64::fulltag-misc) (bne crf0 :no-got) (lbz tag ppc64::misc-subtag-offset object) @@ -788,11 +786,14 @@ (define-ppc64-vinsn require-list (() - ((object :lisp)) - ((tag :u8) - (crf :crf))) + ((object :lisp)) + ((tag :u8) + (crfx :crf) + (crfy :crf))) :again - (clrlwi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) - (cmpwi crf tag ppc64::tag-list) - (beq+ crf :got-it) + (cmpdi crfx object ppc64::nil-value) + (clrldi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) + (cmpwi crfy tag ppc64::fulltag-cons) + (beq crfx :got-it) + (beq+ crfy :got-it) (uuo_intcerr arch::error-object-not-list object) (b :again) @@ -800,12 +801,12 @@ (define-ppc64-vinsn require-symbol (() - ((object :lisp)) - ((tag :u8) - (crf :crf))) + ((object :lisp)) + ((tag :u8) + (crf :crf))) :again (cmpwi crf object ppc64::nil-value) (clrlwi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) (beq crf :got-it) - (cmpwi crf tag ppc64::tag-misc) + (cmpwi crf tag ppc64::fulltag-misc) (bne crf :no-got) (lbz tag ppc64::misc-subtag-offset object) @@ -818,9 +819,9 @@ (define-ppc64-vinsn require-character (() - ((object :lisp)) - ((tag :u8) - (crf :crf))) + ((object :lisp)) + ((tag :u8) + (crf :crf))) :again - (clrlwi tag object (- ppc64::nbits-in-word ppc64::num-subtag-bits)) + (clrldi tag object (- ppc64::nbits-in-word ppc64::num-subtag-bits)) (cmpwi crf tag ppc64::subtag-character) (beq+ crf :got-it) @@ -831,9 +832,9 @@ (define-ppc64-vinsn require-u8 (() - ((object :lisp)) - ((crf0 (:crf 0)) - (tag :u32))) + ((object :lisp)) + ((crf0 (:crf 0)) + (tag :u32))) :again - ; The bottom ppc64::fixnumshift bits and the top (- 32 (+ ppc64::fixnumshift 8)) must all be zero. + ; The bottom ppc64::fixnumshift bits and the top (- 32 (+ ppc64::fixnumshift 8)) must all be zero. (rlwinm. tag object 0 (- ppc64::nbits-in-word ppc64::fixnumshift) (- ppc64::least-significant-bit (+ ppc64::fixnumshift 8))) (beq+ crf0 :got-it) @@ -843,13 +844,13 @@ (define-ppc64-vinsn box-fixnum (((dest :imm)) - ((src :s32))) + ((src :s32))) (slwi dest src ppc64::fixnumshift)) (define-ppc64-vinsn fixnum->s32 (((dest :s32)) - ((src :imm))) + ((src :imm))) (srawi dest src ppc64::fixnumshift)) (define-ppc64-vinsn fixnum->u32 (((dest :u32)) - ((src :imm))) + ((src :imm))) (srwi dest src ppc64::fixnumshift)) @@ -860,12 +861,12 @@ (define-ppc64-vinsn unbox-u32 (((dest :u32)) - ((src :lisp)) - ((crf0 (:crf 0)) - (crf1 :crf))) + ((src :lisp)) + ((crf0 (:crf 0)) + (crf1 :crf))) (rlwinm. dest src 0 (- ppc64::nbits-in-word ppc64::fixnumshift) 0) (srwi dest src ppc64::fixnumshift) (beq+ crf0 :got-it) (clrlwi dest src (- ppc64::nbits-in-word ppc64::nlisptagbits)) - (cmpwi crf0 dest ppc64::tag-misc) + (cmpwi crf0 dest ppc64::fulltag-misc) (bne- crf0 :bad) (lwz dest ppc64::misc-header-offset src) @@ -891,11 +892,11 @@ (define-ppc64-vinsn unbox-s32 (((dest :s32)) - ((src :lisp)) - ((crfx :crf) - (crfy :crf) - (tag :u32))) + ((src :lisp)) + ((crfx :crf) + (crfy :crf) + (tag :u32))) (clrlwi tag src (- ppc64::nbits-in-word ppc64::nlisptagbits)) (cmpwi crfx tag ppc64::tag-fixnum) - (cmpwi crfy tag ppc64::tag-misc) + (cmpwi crfy tag ppc64::fulltag-misc) (srawi dest src ppc64::fixnumshift) (beq+ crfx :got-it) @@ -913,11 +914,11 @@ ; Say that it's not (signed-byte 32) if neither. (define-ppc64-vinsn unbox-x32 (((dest :u32)) - ((src :lisp)) - ((crfx :crf) - (crfy :crf) - (tag :u32))) + ((src :lisp)) + ((crfx :crf) + (crfy :crf) + (tag :u32))) (clrlwi tag src (- ppc64::nbits-in-word ppc64::nlisptagbits)) (cmpwi crfx tag ppc64::tag-fixnum) - (cmpwi crfy tag ppc64::tag-misc) + (cmpwi crfy tag ppc64::fulltag-misc) (srawi dest src ppc64::fixnumshift) (beq+ crfx :got-it) @@ -937,7 +938,8 @@ (define-ppc64-vinsn unbox-u16 (((dest :u16)) - ((src :lisp)) - ((crf0 (:crf 0)))) - ; The bottom ppc64::fixnumshift bits and the top (- 31 (+ ppc64::fixnumshift 16)) must all be zero. + ((src :lisp)) + ((crf0 (:crf 0)))) + ;; The bottom ppc64::fixnumshift bits and the top (- 31 (+ + ;; ppc64::fixnumshift 16)) must all be zero. (rlwinm. dest src 0 (- ppc64::nbits-in-word ppc64::fixnumshift) (- ppc64::least-significant-bit (+ ppc64::fixnumshift 16))) (rlwinm dest src (- 32 ppc64::fixnumshift) 16 31) @@ -947,6 +949,6 @@ (define-ppc64-vinsn unbox-s16 (((dest :s16)) - ((src :lisp)) - ((crf :crf))) + ((src :lisp)) + ((crf :crf))) (slwi dest src (- 16 ppc64::fixnumshift)) (srawi dest dest (- 16 ppc64::fixnumshift)) @@ -964,7 +966,7 @@ (define-ppc64-vinsn unbox-u8 (((dest :u8)) - ((src :lisp)) - ((crf0 (:crf 0)))) - ; The bottom ppc64::fixnumshift bits and the top (- 31 (+ ppc64::fixnumshift 8)) must all be zero. + ((src :lisp)) + ((crf0 (:crf 0)))) + ; The bottom ppc64::fixnumshift bits and the top (- 31 (+ ppc64::fixnumshift 8)) must all be zero. (rlwinm. dest src 0 (- ppc64::nbits-in-word ppc64::fixnumshift) (- ppc64::least-significant-bit (+ ppc64::fixnumshift 8))) (rlwinm dest src (- 32 ppc64::fixnumshift) 24 31) @@ -974,6 +976,6 @@ (define-ppc64-vinsn unbox-s8 (((dest :s8)) - ((src :lisp)) - ((crf :crf))) + ((src :lisp)) + ((crf :crf))) (slwi dest src (- ppc64::nbits-in-word (+ 8 ppc64::fixnumshift))) (srawi dest dest (- ppc64::nbits-in-word (+ 8 ppc64::fixnumshift))) @@ -989,6 +991,6 @@ (define-ppc64-vinsn unbox-base-char (((dest :u32)) - ((src :lisp)) - ((crf :crf))) + ((src :lisp)) + ((crf :crf))) (rlwinm dest src 8 16 31) (cmpwi crf dest (ash ppc64::subtag-character 8)) @@ -999,6 +1001,6 @@ (define-ppc64-vinsn unbox-character (((dest :u32)) - ((src :lisp)) - ((crf :crf))) + ((src :lisp)) + ((crf :crf))) (clrlwi dest src 24) (cmpwi crf dest ppc64::subtag-character) @@ -1009,6 +1011,6 @@ (define-ppc64-vinsn unbox-bit (((dest :u32)) - ((src :lisp)) - ((crf :crf))) + ((src :lisp)) + ((crf :crf))) (cmplwi crf src (ash 1 ppc64::fixnumshift)) (srawi dest src ppc64::fixnumshift) @@ -1018,6 +1020,6 @@ (define-ppc64-vinsn unbox-bit-bit0 (((dest :u32)) - ((src :lisp)) - ((crf :crf))) + ((src :lisp)) + ((crf :crf))) (cmplwi crf src (ash 1 ppc64::fixnumshift)) (rlwinm dest src (- 32 (1+ ppc64::fixnumshift)) 0 0) @@ -1026,111 +1028,84 @@ :got-it) -(define-ppc64-vinsn fixnum->fpr (((dest :double-float)) - ((src :lisp)) - ((imm :s32))) - (stwu ppc::tsp -16 ppc::tsp) - (stw ppc::tsp 4 ppc::tsp) - (stfd ppc::fp-s32conv 8 ppc::tsp) - (srawi imm src ppc64::fixnumshift) - (xoris imm imm #x8000) - (stw imm 12 ppc::tsp) - (lfd dest 8 ppc::tsp) - (lwz ppc::tsp 0 ppc::tsp) - (fsub dest dest ppc::fp-s32conv)) - - -(define-ppc64-vinsn shift-right-variable-word (((dest :u32)) - ((src :u32) - (sh :u32))) + + + +(define-ppc64-vinsn shift-right-variable-word (((dest :u64)) + ((src :u64) + (sh :u64))) (srw dest src sh)) -(define-ppc64-vinsn u32logandc2 (((dest :u32)) - ((x :u32) - (y :u32))) +(define-ppc64-vinsn u64logandc2 (((dest :u64)) + ((x :u64) + (y :u64))) (andc dest x y)) -(define-ppc64-vinsn u32logior (((dest :u32)) - ((x :u32) - (y :u32))) +(define-ppc64-vinsn u64logior (((dest :u64)) + ((x :u64) + (y :u64))) (or dest x y)) -(define-ppc64-vinsn rotate-left-variable-word (((dest :u32)) - ((src :u32) - (rot :u32))) - (rlwnm dest src rot 0 31)) - -(define-ppc64-vinsn complement-shift-count (((dest :u32)) - ((src :u32))) - (subfic dest src 32)) - -(define-ppc64-vinsn extract-lowbyte (((dest :u32)) - ((src :lisp))) - (clrlwi dest src (- ppc64::nbits-in-word ppc64::num-subtag-bits))) - -; Set DEST to the difference between the low byte of SRC and BYTEVAL. -(define-ppc64-vinsn extract-compare-lowbyte (((dest :u32)) - ((src :lisp) - (byteval :u8const))) - (clrlwi dest src (- ppc64::nbits-in-word ppc64::num-subtag-bits)) - (subi dest dest byteval)) - - -; Set the "EQ" bit in condition-register field CRF if object is -; a fixnum. Leave the object's tag in TAG. -; This is a little easier if CRF is CR0. -(define-ppc64-vinsn eq-if-fixnum (((crf :crf) - (tag :u8)) - ((object :lisp)) - ()) - ((:eq crf 0) - (clrlwi. tag object (- ppc64::nbits-in-word ppc64::nlisptagbits))) - ((:not (:eq crf 0)) - (clrlwi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) - (cmpwi crf tag ppc64::tag-fixnum))) - -(define-ppc64-vinsn trap-unless-tag= (() - ((object :lisp) - (tagval :u16const)) - ((tag :u8))) - (clrlwi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) + +(define-ppc64-vinsn trap-unless-fixnum (() + ((object :lisp)) + ((tag :u8))) + (clrldi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) + (tdnei tag ppc64::tag-fixnum)) + +(define-ppc64-vinsn trap-unless-list (() + ((object :lisp)) + ((tag :u8) + (crf :crf))) + (cmpldi crf object ppc64::nil-value) + (clrldi tag object (- ppc64::nbits-in-word ppc64::ntagbits)) + (beq crf :ok) + (tdnei tag ppc64::fulltag-cons) + :ok) + +(define-ppc64-vinsn trap-unless-uvector (() + ((object :lisp)) + ((tag :u8))) + (clrldi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) + (tdnei tag ppc64::fulltag-misc)) + +(define-ppc64-vinsn trap-unless-fulltag= (() + ((object :lisp) + (tagval :u16const)) + ((tag :u8))) + (clrldi tag object (- ppc64::nbits-in-word ppc64::ntagbits)) (twnei tag tagval)) -(define-ppc64-vinsn trap-unless-fulltag= (() - ((object :lisp) - (tagval :u16const)) - ((tag :u8))) - (clrlwi tag object (- ppc64::nbits-in-word ppc64::ntagbits)) - (twnei tag tagval)) - (define-ppc64-vinsn trap-unless-lowbyte= (() - ((object :lisp) - (tagval :u16const)) - ((tag :u8))) + ((object :lisp) + (tagval :u16const)) + ((tag :u8))) (clrlwi tag object (- ppc64::nbits-in-word 8)) (twnei tag tagval)) (define-ppc64-vinsn trap-unless-typecode= (() - ((object :lisp) - (tagval :u16const)) - ((tag :u8) - (crf :crf))) - (clrlwi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) - (cmpwi crf tag ppc64::tag-misc) + ((object :lisp) + (tagval :u16const)) + ((tag :u8) + (crf :crf))) + (clrldi tag object (- ppc64::nbits-in-word ppc64::ntagbits)) + (cmpdi crf tag ppc64::fulltag-misc) + (clrldi tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) (bne crf :do-trap) (lbz tag ppc64::misc-subtag-offset object) :do-trap - (twnei tag tagval)) + (tdnei tag tagval)) (define-ppc64-vinsn subtract-constant (((dest :imm)) - ((src :imm) - (const :s16const))) + ((src :imm) + (const :s16const))) (subi dest src const)) +#+not-yet (define-ppc64-vinsn trap-unless-numeric-type (() - ((object :lisp) - (maxtype :u16const)) - ((crf0 (:crf 0)) - (tag :u8) - (crfX :crf))) + ((object :lisp) + (maxtype :u16const)) + ((crf0 (:crf 0)) + (tag :u8) + (crfX :crf))) (clrlwi. tag object (- ppc64::nbits-in-word ppc64::nlisptagbits)) (cmpwi tag ppc64::tag-misc) @@ -1146,6 +1121,4 @@ ;; Bit-extraction & boolean operations -(eval-when (:compile-toplevel :execute) - (assert (= ppc64::t-offset #b10001))) ; PPC-bits 31 and 27 set ;; For some mind-numbing reason, IBM decided to call the most significant @@ -1159,7 +1132,7 @@ (define-ppc64-vinsn extract-variable-bit (((dest :u8)) - ((src :u32) - (bitnum :u8)) - ()) + ((src :u32) + (bitnum :u8)) + ()) (rotlw dest src bitnum) (extrwi dest dest 1 0)) @@ -1167,7 +1140,7 @@ (define-ppc64-vinsn extract-variable-bit-fixnum (((dest :imm)) - ((src :u32) - (bitnum :u8)) - ((temp :u32))) + ((src :u32) + (bitnum :u8)) + ((temp :u32))) (rotlw temp src bitnum) (rlwinm dest @@ -1185,13 +1158,13 @@ (define-ppc64-vinsn bit31->truth (((dest :lisp) - (bits :u32)) - ((bits :u32)) - ()) - (rlwimi bits bits (- ppc64::least-significant-bit 27) 27 27) ; bits = 0000...X000X + (bits :u32)) + ((bits :u32)) + ()) + (rlwimi bits bits (- ppc64::least-significant-bit 27) 27 27) ; bits = 0000...X000X (addi dest bits ppc64::nil-value)) (define-ppc64-vinsn invert-bit31 (((bits :u32)) - ((bits :u32)) - ()) + ((bits :u32)) + ()) (xori bits bits 1)) @@ -1212,21 +1185,21 @@ (define-ppc64-vinsn eq0->bit31 (((bits :u32)) - ((src (t (:ne bits))))) + ((src (t (:ne bits))))) (cntlzw bits src) - (srwi bits bits 5)) ; bits = 0000...000X + (srwi bits bits 5)) ; bits = 0000...000X (define-ppc64-vinsn ne0->bit31 (((bits :u32)) - ((src (t (:ne bits))))) + ((src (t (:ne bits))))) (cntlzw bits src) (slw bits src bits) - (srwi bits bits 31)) ; bits = 0000...000X + (srwi bits bits 31)) ; bits = 0000...000X (define-ppc64-vinsn lt0->bit31 (((bits :u32)) - ((src (t (:ne bits))))) + ((src (t (:ne bits))))) (srwi bits src 31)) ; bits = 0000...000X (define-ppc64-vinsn ge0->bit31 (((bits :u32)) - ((src (t (:ne bits))))) + ((src (t (:ne bits))))) (srwi bits src 31) (xori bits bits 1)) ; bits = 0000...000X @@ -1234,5 +1207,5 @@ (define-ppc64-vinsn le0->bit31 (((bits :u32)) - ((src (t (:ne bits))))) + ((src (t (:ne bits))))) (neg bits src) (orc bits bits src) @@ -1240,5 +1213,5 @@ (define-ppc64-vinsn gt0->bit31 (((bits :u32)) - ((src (t (:ne bits))))) + ((src (t (:ne bits))))) (subi bits src 1) (nor bits bits src) @@ -1246,16 +1219,16 @@ (define-ppc64-vinsn ne->bit31 (((bits :u32)) - ((x t) - (y t)) - ((temp :u32))) + ((x t) + (y t)) + ((temp :u32))) (subf temp x y) (cntlzw bits temp) (slw bits temp bits) - (srwi bits bits 31)) ; bits = 0000...000X + (srwi bits bits 31)) ; bits = 0000...000X (define-ppc64-vinsn fulltag->bit31 (((bits :u32)) - ((lispobj :lisp) - (tagval :u8const)) - ()) + ((lispobj :lisp) + (tagval :u8const)) + ()) (clrlwi bits lispobj (- ppc64::nbits-in-word ppc64::ntagbits)) (subi bits bits tagval) @@ -1265,12 +1238,12 @@ (define-ppc64-vinsn eq->bit31 (((bits :u32)) - ((x t) - (y t))) + ((x t) + (y t))) (subf bits x y) (cntlzw bits bits) - (srwi bits bits 5)) ; bits = 0000...000X + (srwi bits bits 5)) ; bits = 0000...000X (define-ppc64-vinsn eqnil->bit31 (((bits :u32)) - ((x t))) + ((x t))) (subi bits x ppc64::nil-value) (cntlzw bits bits) @@ -1278,6 +1251,6 @@ (define-ppc64-vinsn ne->bit31 (((bits :u32)) - ((x t) - (y t))) + ((x t) + (y t))) (subf bits x y) (cntlzw bits bits) @@ -1286,5 +1259,5 @@ (define-ppc64-vinsn nenil->bit31 (((bits :u32)) - ((x t))) + ((x t))) (subi bits x ppc64::nil-value) (cntlzw bits bits) @@ -1293,6 +1266,6 @@ (define-ppc64-vinsn lt->bit31 (((bits :u32)) - ((x (t (:ne bits))) - (y (t (:ne bits))))) + ((x (t (:ne bits))) + (y (t (:ne bits))))) (xor bits x y) @@ -1300,9 +1273,9 @@ (or bits bits x) (subf bits y bits) - (srwi bits bits 31)) ; bits = 0000...000X + (srwi bits bits 31)) ; bits = 0000...000X (define-ppc64-vinsn ltu->bit31 (((bits :u32)) - ((x :u32) - (y :u32))) + ((x :u32) + (y :u32))) (subfc bits y x) (subfe bits bits bits) @@ -1310,6 +1283,6 @@ (define-ppc64-vinsn le->bit31 (((bits :u32)) - ((x (t (:ne bits))) - (y (t (:ne bits))))) + ((x (t (:ne bits))) + (y (t (:ne bits))))) (xor bits x y) @@ -1317,15 +1290,15 @@ (nor bits bits y) (add bits bits x) - (srwi bits bits 31)) ; bits = 0000...000X + (srwi bits bits 31)) ; bits = 0000...000X (define-ppc64-vinsn leu->bit31 (((bits :u32)) - ((x :u32) - (y :u32))) + ((x :u32) + (y :u32))) (subfc bits x y) (addze bits ppc::rzero)) (define-ppc64-vinsn gt->bit31 (((bits :u32)) - ((x (t (:ne bits))) - (y (t (:ne bits))))) + ((x (t (:ne bits))) + (y (t (:ne bits))))) (eqv bits x y) @@ -1333,9 +1306,9 @@ (and bits bits x) (subf bits bits y) - (srwi bits bits 31)) ; bits = 0000...000X + (srwi bits bits 31)) ; bits = 0000...000X (define-ppc64-vinsn gtu->bit31 (((bits :u32)) - ((x :u32) - (y :u32))) + ((x :u32) + (y :u32))) (subfc bits x y) (subfe bits bits bits) @@ -1343,15 +1316,15 @@ (define-ppc64-vinsn ge->bit31 (((bits :u32)) - ((x (t (:ne bits))) - (y (t (:ne bits))))) + ((x (t (:ne bits))) + (y (t (:ne bits))))) (eqv bits x y) (srawi bits bits 31) (andc bits bits x) (add bits bits y) - (srwi bits bits 31)) ; bits = 0000...000X + (srwi bits bits 31)) ; bits = 0000...000X (define-ppc64-vinsn geu->bit31 (((bits :u32)) - ((x :u32) - (y :u32))) + ((x :u32) + (y :u32))) (subfc bits y x) (addze bits ppc::rzero)) @@ -1365,80 +1338,80 @@ ; Of course, using a CR field costs us something as well. (define-ppc64-vinsn crbit->bit31 (((bits :u32)) - ((crf :crf) - (bitnum :crbit)) - ()) + ((crf :crf) + (bitnum :crbit)) + ()) (mfcr bits) ; Suffer. - (rlwinm bits bits (:apply + 1 bitnum (:apply ash crf 2)) 31 31)) ; bits = 0000...000X + (rlwinm bits bits (:apply + 1 bitnum (:apply ash crf 2)) 31 31)) ; bits = 0000...000X (define-ppc64-vinsn compare (((crf :crf)) - ((arg0 t) - (arg1 t)) - ()) + ((arg0 t) + (arg1 t)) + ()) (cmpw crf arg0 arg1)) (define-ppc64-vinsn compare-to-nil (((crf :crf)) - ((arg0 t))) + ((arg0 t))) (cmpwi crf arg0 ppc64::nil-value)) (define-ppc64-vinsn compare-logical (((crf :crf)) - ((arg0 t) - (arg1 t)) - ()) + ((arg0 t) + (arg1 t)) + ()) (cmplw crf arg0 arg1)) (define-ppc64-vinsn double-float-compare (((crf :crf)) - ((arg0 :double-float) - (arg1 :double-float)) - ()) + ((arg0 :double-float) + (arg1 :double-float)) + ()) (fcmpo crf arg0 arg1)) (define-ppc64-vinsn double-float+-2 (((result :double-float)) - ((x :double-float) - (y :double-float)) - ((crf (:crf 4)))) + ((x :double-float) + (y :double-float)) + ((crf (:crf 4)))) (fadd result x y)) (define-ppc64-vinsn double-float--2 (((result :double-float)) - ((x :double-float) - (y :double-float)) - ((crf (:crf 4)))) + ((x :double-float) + (y :double-float)) + ((crf (:crf 4)))) (fsub result x y)) (define-ppc64-vinsn double-float*-2 (((result :double-float)) - ((x :double-float) - (y :double-float)) - ((crf (:crf 4)))) + ((x :double-float) + (y :double-float)) + ((crf (:crf 4)))) (fmul result x y)) (define-ppc64-vinsn double-float/-2 (((result :double-float)) - ((x :double-float) - (y :double-float)) - ((crf (:crf 4)))) + ((x :double-float) + (y :double-float)) + ((crf (:crf 4)))) (fdiv result x y)) (define-ppc64-vinsn single-float+-2 (((result :single-float)) - ((x :single-float) - (y :single-float)) - ((crf (:crf 4)))) + ((x :single-float) + (y :single-float)) + ((crf (:crf 4)))) (fadds result x y)) (define-ppc64-vinsn single-float--2 (((result :single-float)) - ((x :single-float) - (y :single-float)) - ((crf (:crf 4)))) + ((x :single-float) + (y :single-float)) + ((crf (:crf 4)))) (fsubs result x y)) (define-ppc64-vinsn single-float*-2 (((result :single-float)) - ((x :single-float) - (y :single-float)) - ((crf (:crf 4)))) + ((x :single-float) + (y :single-float)) + ((crf (:crf 4)))) (fmuls result x y)) (define-ppc64-vinsn single-float/-2 (((result :single-float)) - ((x :single-float) - (y :single-float)) - ((crf (:crf 4)))) + ((x :single-float) + (y :single-float)) + ((crf (:crf 4)))) (fdivs result x y)) @@ -1448,19 +1421,19 @@ (define-ppc64-vinsn compare-unsigned (((crf :crf)) - ((arg0 :imm) - (arg1 :imm)) - ()) + ((arg0 :imm) + (arg1 :imm)) + ()) (cmplw crf arg0 arg1)) (define-ppc64-vinsn compare-signed-s16const (((crf :crf)) - ((arg0 :imm) - (imm :s16const)) - ()) + ((arg0 :imm) + (imm :s16const)) + ()) (cmpwi crf arg0 imm)) (define-ppc64-vinsn compare-unsigned-u16const (((crf :crf)) - ((arg0 :u32) - (imm :u16const)) - ()) + ((arg0 :u32) + (imm :u16const)) + ()) (cmplwi crf arg0 imm)) @@ -1470,19 +1443,19 @@ ;; Bitnum is treated mod 32. (define-ppc64-vinsn extract-constant-ppc-bit (((dest :u32)) - ((src :imm) - (bitnum :u16const)) - ()) + ((src :imm) + (bitnum :u16const)) + ()) (rlwinm dest src (:apply + 1 bitnum) 31 31)) (define-ppc64-vinsn set-constant-ppc-bit-to-variable-value (((dest :u32)) - ((src :u32) - (bitval :u32) ; 0 or 1 - (bitnum :u8const))) + ((src :u32) + (bitval :u32) ; 0 or 1 + (bitnum :u8const))) (rlwimi dest bitval (:apply - 31 bitnum) bitnum bitnum)) (define-ppc64-vinsn set-constant-ppc-bit-to-1 (((dest :u32)) - ((src :u32) - (bitnum :u8const))) + ((src :u32) + (bitnum :u8const))) ((:pred < bitnum 16) (oris dest src (:apply ash #x8000 (:apply - bitnum)))) @@ -1491,12 +1464,12 @@ (define-ppc64-vinsn set-constant-ppc-bit-to-0 (((dest :u32)) - ((src :u32) - (bitnum :u8const))) + ((src :u32) + (bitnum :u8const))) (rlwinm dest src 0 (:apply logand #x1f (:apply 1+ bitnum)) (:apply logand #x1f (:apply 1- bitnum)))) (define-ppc64-vinsn insert-bit-0 (((dest :u32)) - ((src :u32) - (val :u32))) + ((src :u32) + (val :u32))) (rlwimi dest val 0 0 0)) @@ -1509,7 +1482,7 @@ ; Actually, it'd be "unbox, then subtract from 30". (define-ppc64-vinsn extract-variable-non-insane-bit (((dest :u32)) - ((src :imm) - (bit :imm)) - ((temp :u32))) + ((src :imm) + (bit :imm)) + ((temp :u32))) (srwi temp bit ppc64::fixnumshift) (subfic temp temp (- 32 ppc64::fixnumshift)) @@ -1519,32 +1492,32 @@ (define-ppc64-vinsn %cdr (((dest :lisp)) - ((src :lisp))) - (lwz dest ppc64::cons.cdr src)) + ((src :lisp))) + (ld dest ppc64::cons.cdr src)) (define-ppc64-vinsn %car (((dest :lisp)) - ((src :lisp))) - (lwz dest ppc64::cons.car src)) + ((src :lisp))) + (ld dest ppc64::cons.car src)) (define-ppc64-vinsn %set-car (() - ((cell :lisp) - (new :lisp))) - (stw new ppc64::cons.car cell)) + ((cell :lisp) + (new :lisp))) + (std new ppc64::cons.car cell)) (define-ppc64-vinsn %set-cdr (() - ((cell :lisp) - (new :lisp))) - (stw new ppc64::cons.cdr cell)) + ((cell :lisp) + (new :lisp))) + (std new ppc64::cons.cdr cell)) (define-ppc64-vinsn load-adl (() - ((n :u32const))) + ((n :u32const))) (lis ppc::nargs (:apply ldb (byte 16 16) n)) (ori ppc::nargs ppc::nargs (:apply ldb (byte 16 0) n))) (define-ppc64-vinsn set-nargs (() - ((n :s16const))) + ((n :s16const))) (li ppc::nargs (:apply ash n ppc64::word-shift))) (define-ppc64-vinsn scale-nargs (() - ((nfixed :s16const))) + ((nfixed :s16const))) ((:pred > nfixed 0) (la ppc::nargs (:apply - (:apply ash nfixed ppc64::word-shift)) ppc::nargs))) @@ -1555,20 +1528,20 @@ (() ((reg :lisp))) - (stwu reg -4 ppc::vsp)) + (stdu reg -8 ppc::vsp)) (define-ppc64-vinsn (vpush-register-arg :push :node :vsp :outgoing-argument) (() ((reg :lisp))) - (stwu reg -4 ppc::vsp)) + (stdu reg -8 ppc::vsp)) (define-ppc64-vinsn (vpop-register :pop :node :vsp) (((dest :lisp)) ()) - (lwz dest 0 ppc::vsp) - (la ppc::vsp 4 ppc::vsp)) + (ld dest 0 ppc::vsp) + (la ppc::vsp ppc64::word-size-in-bytes ppc::vsp)) (define-ppc64-vinsn copy-node-gpr (((dest :lisp)) - ((src :lisp))) + ((src :lisp))) ((:not (:pred = (:apply %hard-regspec-value dest) @@ -1577,5 +1550,5 @@ (define-ppc64-vinsn copy-gpr (((dest t)) - ((src t))) + ((src t))) ((:not (:pred = (:apply %hard-regspec-value dest) @@ -1584,6 +1557,6 @@ -(define-ppc64-vinsn copy-fpr (((dest t)) - ((src t))) +(define-ppc64-vinsn copy-fpr (((dest :double-float)) + ((src :double-float))) ((:not (:pred = (:apply %hard-regspec-value dest) @@ -1592,59 +1565,61 @@ (define-ppc64-vinsn vcell-ref (((dest :lisp)) - ((vcell :lisp))) - (lwz dest ppc64::misc-data-offset vcell)) + ((vcell :lisp))) + (ld dest ppc64::misc-data-offset vcell)) (define-ppc64-vinsn vcell-set (() - ((vcell :lisp) - (value :lisp))) - (stw value ppc64::misc-data-offset vcell)) + ((vcell :lisp) + (value :lisp))) + (std value ppc64::misc-data-offset vcell)) (define-ppc64-vinsn make-vcell (((dest :lisp)) - ((closed (:lisp :ne dest))) - ((header :u32))) + ((closed (:lisp :ne dest))) + ((header :u64))) (li header ppc64::value-cell-header) (la ppc::allocptr (- ppc64::fulltag-misc ppc64::value-cell.size) ppc::allocptr) - (twllt ppc::allocptr ppc::allocbase) - (stw header ppc64::misc-header-offset ppc::allocptr) + (tdllt ppc::allocptr ppc::allocbase) + (std header ppc64::misc-header-offset ppc::allocptr) (mr dest ppc::allocptr) - (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits) - (stw closed ppc64::value-cell.value dest)) + (rldicr ppc::allocptr ppc::allocptr 0 (- 63 ppc64::ntagbits)) + (std closed ppc64::value-cell.value dest)) (define-ppc64-vinsn make-tsp-vcell (((dest :lisp)) - ((closed :lisp)) - ((header :u32))) + ((closed :lisp)) + ((header :u64))) (li header ppc64::value-cell-header) - (stwu ppc::tsp -16 ppc::tsp) - (stw ppc::tsp 4 ppc::tsp) - (stfd ppc::fp-zero 8 ppc::tsp) - (stw ppc::rzero 4 ppc::tsp) - (stw header (+ 8 ppc64::fulltag-misc ppc64::value-cell.header) ppc::tsp) - (stw closed (+ 8 ppc64::fulltag-misc ppc64::value-cell.value) ppc::tsp) - (la dest (+ 8 ppc64::fulltag-misc) ppc::tsp)) + (stdu ppc::tsp -32 ppc::tsp) + (std ppc::tsp 8 ppc::tsp) + (stfd ppc::fp-zero 16 ppc::tsp) + (stfd ppc::fp-zero 24 ppc::tsp) + (std ppc::rzero 8 ppc::tsp) + (std header (+ 16 ppc64::fulltag-misc ppc64::value-cell.header) ppc::tsp) + (std closed (+ 16 ppc64::fulltag-misc ppc64::value-cell.value) ppc::tsp) + (la dest (+ 16 ppc64::fulltag-misc) ppc::tsp)) (define-ppc64-vinsn make-tsp-cons (((dest :lisp)) - ((car :lisp) (cdr :lisp)) - ()) - (stwu ppc::tsp -16 ppc::tsp) - (stw ppc::tsp 4 ppc::tsp) - (stfd ppc::fp-zero 8 ppc::tsp) - (stw ppc::rzero 4 ppc::tsp) - (stw car (+ 8 ppc64::fulltag-cons ppc64::cons.car) ppc::tsp) - (stw cdr (+ 8 ppc64::fulltag-cons ppc64::cons.cdr) ppc::tsp) - (la dest (+ 8 ppc64::fulltag-cons) ppc::tsp)) + ((car :lisp) (cdr :lisp)) + ()) + (stdu ppc::tsp -32 ppc::tsp) + (std ppc::tsp 8 ppc::tsp) + (stfd ppc::fp-zero 16 ppc::tsp) + (stfd ppc::fp-zero 24 ppc::tsp) + (std ppc::rzero 8 ppc::tsp) + (std car (+ 16 ppc64::fulltag-cons ppc64::cons.car) ppc::tsp) + (std cdr (+ 16 ppc64::fulltag-cons ppc64::cons.cdr) ppc::tsp) + (la dest (+ 16 ppc64::fulltag-cons) ppc::tsp)) (define-ppc64-vinsn %closure-code% (((dest :lisp)) - ()) + ()) (lwz dest (+ ppc64::symbol.vcell (ppc64::nrs-offset %closure-code%) ppc64::nil-value) 0)) (define-ppc64-vinsn (call-subprim :call :subprim-call) (() - ((spno :s32const))) + ((spno :s32const))) (bla spno)) (define-ppc64-vinsn (jump-subprim :jumpLR) (() - ((spno :s32const))) + ((spno :s32const))) (ba spno)) @@ -1652,27 +1627,27 @@ ; track args, results, etc. (define-ppc64-vinsn (call-subprim-0 :call :subprim-call) (((dest t)) - ((spno :s32const))) + ((spno :s32const))) (bla spno)) (define-ppc64-vinsn (call-subprim-1 :call :subprim-call) (((dest t)) - ((spno :s32const) - (z t))) + ((spno :s32const) + (z t))) (bla spno)) (define-ppc64-vinsn (call-subprim-2 :call :subprim-call) (((dest t)) - ((spno :s32const) - (y t) - (z t))) + ((spno :s32const) + (y t) + (z t))) (bla spno)) (define-ppc64-vinsn (call-subprim-3 :call :subprim-call) (((dest t)) - ((spno :s32const) - (x t) - (y t) - (z t))) + ((spno :s32const) + (x t) + (y t) + (z t))) (bla spno)) (define-ppc64-vinsn event-poll (() - ()) + ()) (lwz ppc::nargs ppc64::tcr.interrupt-level ppc::rcontext) (twgti ppc::nargs 0)) @@ -1686,5 +1661,5 @@ (define-ppc64-vinsn (call-label :call) (() - ((label :label))) + ((label :label))) (bl label)) @@ -1692,22 +1667,22 @@ ; code is somehow reachable. (define-ppc64-vinsn (non-barrier-jump :xref) (() - ((label :label))) + ((label :label))) (b label)) (define-ppc64-vinsn (cbranch-true :branch) (() - ((label :label) - (crf :crf) - (crbit :u8const))) + ((label :label) + (crf :crf) + (crbit :u8const))) (bt (:apply + crf crbit) label)) (define-ppc64-vinsn (cbranch-false :branch) (() - ((label :label) - (crf :crf) - (crbit :u8const))) + ((label :label) + (crf :crf) + (crbit :u8const))) (bf (:apply + crf crbit) label)) (define-ppc64-vinsn check-trap-error (() - ()) + ()) (beq+ 0 :no-error) (uuo_interr arch::error-reg-regnum ppc::arg_z) @@ -1716,11 +1691,11 @@ (define-ppc64-vinsn lisp-word-ref (((dest t)) - ((base t) - (offset t))) + ((base t) + (offset t))) (lwzx dest base offset)) (define-ppc64-vinsn lisp-word-ref-c (((dest t)) - ((base t) - (offset :s16const))) + ((base t) + (offset :s16const))) (lwz dest offset base)) @@ -1729,6 +1704,6 @@ ;; Load an unsigned, 32-bit constant into a destination register. (define-ppc64-vinsn (lwi :constant-ref) (((dest :imm)) - ((intval :u32const)) - ()) + ((intval :u32const)) + ()) ((:or (:pred = (:apply ash intval -15) #x1ffff) (:pred = (:apply ash intval -15) #x0)) @@ -1746,6 +1721,6 @@ ; Exactly the same thing, but take a signed integer value (define-ppc64-vinsn lwi-s32 (((dest :imm)) - ((intval :s32const)) - ()) + ((intval :s32const)) + ()) ((:or (:pred = (:apply ash intval -15) -1) (:pred = (:apply ash intval -15) #x0)) @@ -1762,5 +1737,5 @@ (define-ppc64-vinsn discard-temp-frame (() - ()) + ()) (lwz ppc::tsp 0 ppc::tsp)) @@ -1774,5 +1749,5 @@ ;;; (large chunks of which are unused). (define-ppc64-vinsn alloc-c-frame (() - ((n-c-args :u16const))) + ((n-c-args :u16const))) ;; Always reserve space for at least 8 args and space for a lisp ;; frame (for the kernel) underneath it. @@ -1802,5 +1777,5 @@ (define-ppc64-vinsn alloc-eabi-c-frame (() - ((n-c-args :u16const))) + ((n-c-args :u16const))) ; Always reserve space for at least 8 args and space for a lisp ; frame (for the kernel) underneath it. Store NIL inthe c-frame's @@ -1827,5 +1802,5 @@ ; of each frame. (define-ppc64-vinsn discard-c-frame (() - ()) + ()) (lwz ppc::sp 0 ppc::sp)) @@ -1834,59 +1809,61 @@ (define-ppc64-vinsn set-c-arg (() - ((argval :u32) - (argnum :u16const))) + ((argval :u32) + (argnum :u16const))) (stw argval (:apply + ppc64::c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn set-single-c-arg (() - ((argval :single-float) - (argnum :u16const))) + ((argval :single-float) + (argnum :u16const))) (stfs argval (:apply + ppc64::c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn set-double-c-arg (() - ((argval :double-float) - (argnum :u16const))) + ((argval :double-float) + (argnum :u16const))) (stfd argval (:apply + ppc64::c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn reload-single-c-arg (((argval :single-float)) - ((argnum :u16const))) + ((argnum :u16const))) (lfs argval (:apply + ppc64::c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn reload-double-c-arg (((argval :double-float)) - ((argnum :u16const))) + ((argnum :u16const))) (lfd argval (:apply + ppc64::c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn set-eabi-c-arg (() - ((argval :u32) - (argnum :u16const))) + ((argval :u32) + (argnum :u16const))) (stw argval (:apply + ppc64::eabi-c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn set-single-eabi-c-arg (() - ((argval :single-float) - (argnum :u16const))) + ((argval :single-float) + (argnum :u16const))) (stfs argval (:apply + ppc64::eabi-c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn set-double-eabi-c-arg (() - ((argval :double-float) - (argnum :u16const))) + ((argval :double-float) + (argnum :u16const))) (stfd argval (:apply + ppc64::eabi-c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn reload-single-eabi-c-arg (((argval :single-float)) - ((argnum :u16const))) + ((argnum :u16const))) (lfs argval (:apply + ppc64::eabi-c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn reload-double-eabi-c-arg (((argval :double-float)) - ((argnum :u16const))) + ((argnum :u16const))) (lfd argval (:apply + ppc64::eabi-c-frame.param0 (:apply ash argnum ppc64::word-shift)) ppc::sp)) (define-ppc64-vinsn (load-nil :constant-ref) (((dest t)) - ()) + ()) (li dest ppc64::nil-value)) + +#+not-yet (define-ppc64-vinsn (load-t :constant-ref) (((dest t)) - ()) + ()) (li dest (+ ppc64::t-offset ppc64::nil-value))) (define-ppc64-vinsn set-eq-bit (((dest :crf)) - ()) + ()) (creqv (:apply + ppc::ppc-eq-bit dest) (:apply + ppc::ppc-eq-bit dest) @@ -1894,21 +1871,21 @@ (define-ppc64-vinsn (ref-constant :constant-ref) (((dest :lisp)) - ((src :s16const))) - (lwz dest (:apply + ppc64::misc-data-offset (:apply ash (:apply 1+ src) 2)) ppc::fn)) + ((src :s16const))) + (ld dest (:apply + ppc64::misc-data-offset (:apply ash (:apply 1+ src) 3)) ppc::fn)) (define-ppc64-vinsn ref-indexed-constant (((dest :lisp)) - ((idxreg :s32))) - (lwzx dest ppc::fn idxreg)) + ((idxreg :s32))) + (ldx dest ppc::fn idxreg)) (define-ppc64-vinsn cons (((dest :lisp)) - ((newcar :lisp) - (newcdr :lisp))) + ((newcar :lisp) + (newcdr :lisp))) (la ppc::allocptr (- ppc64::fulltag-cons ppc64::cons.size) ppc::allocptr) - (twllt ppc::allocptr ppc::allocbase) - (stw newcdr ppc64::cons.cdr ppc::allocptr) - (stw newcar ppc64::cons.car ppc::allocptr) + (tdllt ppc::allocptr ppc::allocbase) + (std newcdr ppc64::cons.cdr ppc::allocptr) + (std newcar ppc64::cons.car ppc::allocptr) (mr dest ppc::allocptr) - (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits)) + (rldicr ppc::allocptr ppc::allocptr 0 (- 63 ppc64::ntagbits))) @@ -1916,9 +1893,9 @@ ;; subtag had better be a PPC-NODE-SUBTAG of some sort! (define-ppc64-vinsn %ppc-gvector (((dest :lisp)) - ((Rheader :u32) - (nbytes :u32const)) - ((immtemp0 :u32) - (nodetemp :lisp) - (crf :crf))) + ((Rheader :u32) + (nbytes :u32const)) + ((immtemp0 :u32) + (nodetemp :lisp) + (crf :crf))) (la ppc::allocptr (:apply - ppc64::fulltag-misc (:apply logand (lognot 7) @@ -1928,5 +1905,5 @@ (stw Rheader ppc64::misc-header-offset ppc::allocptr) (mr dest ppc::allocptr) - (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits) + (rldicr ppc::allocptr ppc::allocptr 0 (- 63 ppc64::ntagbits)) ((:not (:pred = nbytes 0)) (li immtemp0 (:apply + ppc64::misc-data-offset nbytes)) @@ -1941,17 +1918,17 @@ ;; allocate a small (phys size <= 32K bytes) misc obj of known size/subtag (define-ppc64-vinsn %alloc-misc-fixed (((dest :lisp)) - ((Rheader :u32) - (nbytes :u32const))) + ((Rheader :u64) + (nbytes :u32const))) (la ppc::allocptr (:apply - ppc64::fulltag-misc - (:apply logand (lognot 7) - (:apply + (+ 7 4) nbytes))) + (:apply logand (lognot 15) + (:apply + (+ 15 8) nbytes))) ppc::allocptr) - (twllt ppc::allocptr ppc::allocbase) - (stw Rheader ppc64::misc-header-offset ppc::allocptr) + (tdllt ppc::allocptr ppc::allocbase) + (std Rheader ppc64::misc-header-offset ppc::allocptr) (mr dest ppc::allocptr) - (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits)) + (rldicr ppc::allocptr ppc::allocptr 0 (- 63 ppc64::ntagbits))) (define-ppc64-vinsn vstack-discard (() - ((nwords :u32const))) + ((nwords :u32const))) ((:not (:pred = nwords 0)) (la ppc::vsp (:apply ash nwords ppc64::word-shift) ppc::vsp))) @@ -1959,19 +1936,19 @@ (define-ppc64-vinsn lcell-load (((dest :lisp)) - ((cell :lcell) - (top :lcell))) - (lwz dest (:apply - - (:apply - (:apply calc-lcell-depth top) 4) - (:apply calc-lcell-offset cell)) ppc::vsp)) + ((cell :lcell) + (top :lcell))) + (ld dest (:apply - + (:apply - (:apply calc-lcell-depth top) ppc64::word-size-in-bytes) + (:apply calc-lcell-offset cell)) ppc::vsp)) (define-ppc64-vinsn vframe-load (((dest :lisp)) - ((frame-offset :u16const) - (cur-vsp :u16const))) - (lwz dest (:apply - (:apply - cur-vsp 4) frame-offset) ppc::vsp)) + ((frame-offset :u16const) + (cur-vsp :u16const))) + (ld dest (:apply - (:apply - cur-vsp ppc64::word-size-in-bytes) frame-offset) ppc::vsp)) (define-ppc64-vinsn lcell-store (() - ((src :lisp) - (cell :lcell) - (top :lcell))) + ((src :lisp) + (cell :lcell) + (top :lcell))) (stw src (:apply - (:apply - (:apply calc-lcell-depth top) 4) @@ -1979,18 +1956,18 @@ (define-ppc64-vinsn vframe-store (() - ((src :lisp) - (frame-offset :u16const) - (cur-vsp :u16const))) - (stw src (:apply - (:apply - cur-vsp 4) frame-offset) ppc::vsp)) + ((src :lisp) + (frame-offset :u16const) + (cur-vsp :u16const))) + (std src (:apply - (:apply - cur-vsp 8) frame-offset) ppc::vsp)) (define-ppc64-vinsn load-vframe-address (((dest :imm)) - ((offset :s16const))) + ((offset :s16const))) (la dest offset ppc::vsp)) (define-ppc64-vinsn copy-lexpr-argument (() - () - ((temp :lisp))) - (lwzx temp ppc::vsp ppc::nargs) - (stwu temp -4 ppc::vsp)) + () + ((temp :lisp))) + (ldx temp ppc::vsp ppc::nargs) + (stdu temp -8 ppc::vsp)) ; Boxing/unboxing of integers. @@ -1998,12 +1975,12 @@ ; Treat the low 8 bits of VAL as an unsigned integer; set RESULT to the equivalent fixnum. (define-ppc64-vinsn u8->fixnum (((result :imm)) - ((val :u8)) - ()) + ((val :u8)) + ()) (rlwinm result val ppc64::fixnumshift (- ppc64::nbits-in-word (+ 8 ppc64::fixnumshift)) (- ppc64::least-significant-bit ppc64::fixnumshift))) ; Treat the low 8 bits of VAL as a signed integer; set RESULT to the equivalent fixnum. (define-ppc64-vinsn s8->fixnum (((result :imm)) - ((val :s8)) - ()) + ((val :s8)) + ()) (extlwi result val 8 (- ppc64::nbits-in-word 8)) (srawi result result (- (- ppc64::nbits-in-word 8) ppc64::fixnumshift))) @@ -2012,37 +1989,38 @@ ; Treat the low 16 bits of VAL as an unsigned integer; set RESULT to the equivalent fixnum. (define-ppc64-vinsn u16->fixnum (((result :imm)) - ((val :u16)) - ()) + ((val :u16)) + ()) (rlwinm result val ppc64::fixnumshift (- ppc64::nbits-in-word (+ 16 ppc64::fixnumshift)) (- ppc64::least-significant-bit ppc64::fixnumshift))) ; Treat the low 16 bits of VAL as a signed integer; set RESULT to the equivalent fixnum. (define-ppc64-vinsn s16->fixnum (((result :imm)) - ((val :s16)) - ()) + ((val :s16)) + ()) (extlwi result val 16 (- ppc64::nbits-in-word 16)) (srawi result result (- (- ppc64::nbits-in-word 16) ppc64::fixnumshift))) (define-ppc64-vinsn fixnum->s16 (((result :s16)) - ((src :imm))) + ((src :imm))) (srawi result src ppc64::fixnumshift)) -; A signed 32-bit untagged value can be at worst a 1-digit bignum. +; A signed 64-bit untagged value can be at worst a 1-digit bignum. ; There should be something very much like this that takes a stack-consed ; bignum result ... -(define-ppc64-vinsn s32->integer (((result :lisp)) - ((src :s32)) - ((crf (:crf 0)) ; a casualty - (temp :s32))) +(define-ppc64-vinsn s64->integer (((result :lisp)) + ((src :s64)) + ((crf (:crf 0)) ; a casualty + (temp :s64))) (addo temp src src) + (addo temp temp temp) (addo. result temp temp) (bns+ :done) (mtxer ppc::rzero) (li temp ppc64::one-digit-bignum-header) - (la ppc::allocptr (- ppc64::fulltag-misc 8) ppc::allocptr) - (twllt ppc::allocptr ppc::allocbase) - (stw temp ppc64::misc-header-offset ppc::allocptr) + (la ppc::allocptr (- ppc64::fulltag-misc 16) ppc::allocptr) + (tdllt ppc::allocptr ppc::allocbase) + (std temp ppc64::misc-header-offset ppc::allocptr) (mr result ppc::allocptr) - (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits) - (stw src ppc64::misc-data-offset result) + (rldicr ppc::allocptr ppc::allocptr 0 (- 63 ppc64::ntagbits)) + (std src ppc64::misc-data-offset result) :done) @@ -2050,41 +2028,41 @@ ; An unsigned 32-bit untagged value can be either a 1 or a 2-digit bignum. (define-ppc64-vinsn u32->integer (((result :lisp)) - ((src :u32)) - ((crf (:crf 0)) ; a casualty - (temp :s32) - (size :u32))) - (clrrwi. temp src (- ppc64::least-significant-bit ppc64::nfixnumtagbits)) - (slwi result src ppc64::fixnumshift) + ((src :u32)) + ((crf (:crf 0)) ; a casualty + (temp :s32) + (size :u32))) + (rldicr. temp src 0 ppc64::nfixnumtagbits) + (sldi result src ppc64::fixnumshift) (beq+ crf :done) - (cmpwi src 0) + (cmpdi src 0) (li temp ppc64::one-digit-bignum-header) - (li size (- 8 ppc64::fulltag-misc)) + (li size (- 16 ppc64::fulltag-misc)) (bgt :common) (li temp ppc64::two-digit-bignum-header) - (li size (- 16 ppc64::fulltag-misc)) + (li size (- 24 ppc64::fulltag-misc)) :common (sub ppc::allocptr ppc::allocptr size) - (twllt ppc::allocptr ppc::allocbase) - (stw temp ppc64::misc-header-offset ppc::allocptr) + (tdllt ppc::allocptr ppc::allocbase) + (std temp ppc64::misc-header-offset ppc::allocptr) (mr result ppc::allocptr) - (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits) - (stw src ppc64::misc-data-offset result) + (rldicr ppc::allocptr ppc::allocptr 0 (- 63 ppc64::ntagbits)) + (std src ppc64::misc-data-offset result) :done) (define-ppc64-vinsn u16->u32 (((dest :u32)) - ((src :u16))) + ((src :u16))) (clrlwi dest src 16)) (define-ppc64-vinsn u8->u32 (((dest :u32)) - ((src :u8))) + ((src :u8))) (clrlwi dest src 24)) (define-ppc64-vinsn s16->s32 (((dest :s32)) - ((src :s16))) + ((src :s16))) (extsh dest src)) (define-ppc64-vinsn s8->s32 (((dest :s32)) - ((src :s8))) + ((src :s8))) (extsb dest src)) @@ -2095,40 +2073,31 @@ ; this blindly. (define-ppc64-vinsn double->heap (((result :lisp)) ; tagged as a double-float - ((fpreg :double-float)) - ((header-temp :u32))) + ((fpreg :double-float)) + ((header-temp :u32))) (li header-temp (arch::make-vheader ppc64::double-float.element-count ppc64::subtag-double-float)) (la ppc::allocptr (- ppc64::fulltag-misc ppc64::double-float.size) ppc::allocptr) - (twllt ppc::allocptr ppc::allocbase) - (stw header-temp ppc64::misc-header-offset ppc::allocptr) + (tdllt ppc::allocptr ppc::allocbase) + (std header-temp ppc64::misc-header-offset ppc::allocptr) (mr result ppc::allocptr) - (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits) + (rldicr ppc::allocptr ppc::allocptr 0 (- 63 ppc64::ntagbits)) (stfd fpreg ppc64::double-float.value result) ) -; This is about as bad as heap-consing a double-float. (In terms of verbosity). -; Wouldn't kill us to do either/both out-of-line, but need to make visible to -; compiler so unnecessary heap-consing can be elided. -(define-ppc64-vinsn single->heap (((result :lisp)) ; tagged as a single-float - ((fpreg :single-float)) - ((header-temp :u32))) - (li header-temp (arch::make-vheader ppc64::single-float.element-count ppc64::subtag-single-float)) - (la ppc::allocptr (- ppc64::fulltag-misc ppc64::single-float.size) ppc::allocptr) - (twllt ppc::allocptr ppc::allocbase) - (stw header-temp ppc64::misc-header-offset ppc::allocptr) - (mr result ppc::allocptr) - (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits) - (stfs fpreg ppc64::single-float.value result)) +(define-ppc64-vinsn single->node (((result :lisp)) ; tagged as a single-float + ((fpreg :single-float))) + (stfs fpreg ppc64::tcr.single-float-convert ppc::rcontext) + (ld result ppc64::tcr.single-float-convert ppc::rcontext)) ; "dest" is preallocated, presumably on a stack somewhere. (define-ppc64-vinsn store-double (() - ((dest :lisp) - (source :double-float)) - ()) + ((dest :lisp) + (source :double-float)) + ()) (stfd source ppc64::double-float.value dest)) (define-ppc64-vinsn get-double (((target :double-float)) - ((source :lisp)) - ()) + ((source :lisp)) + ()) (lfd target ppc64::double-float.value source)) @@ -2138,36 +2107,37 @@ (define-ppc64-vinsn get-double? (((target :double-float)) - ((source :lisp)) - ((tag :u8) - (crf :crf))) - (clrlwi tag source (- ppc64::nbits-in-word ppc64::nlisptagbits)) - (cmpwi crf tag ppc64::tag-misc) + ((source :lisp)) + ((tag :u8) + (crf :crf))) + (clrldi tag source (- ppc64::nbits-in-word ppc64::ntagbits)) + (cmpdi crf tag ppc64::fulltag-misc) (bne crf :do-trap) (lbz tag ppc64::misc-subtag-offset source) :do-trap - (twnei tag ppc64::subtag-double-float) + (tdnei tag ppc64::subtag-double-float) (lfd target ppc64::double-float.value source)) (define-ppc64-vinsn store-single (() - ((dest :lisp) - (source :single-float)) - ()) - (stfs source ppc64::single-float.value dest)) + ((dest :lisp) + (source :single-float)) + ()) + (stfs source ppc64::tcr.single-float-convert ppc::rcontext) + (ld dest ppc64::tcr.single-float-convert ppc::rcontext)) (define-ppc64-vinsn get-single (((target :single-float)) - ((source :lisp)) - ()) - (lfs target ppc64::single-float.value source)) + ((source :lisp))) + (std source ppc64::tcr.single-float-convert ppc::rcontext) + (lfs target ppc64::tcr.single-float-convert ppc::rcontext)) ; ... of characters ... (define-ppc64-vinsn charcode->u16 (((dest :u16)) - ((src :imm)) - ()) + ((src :imm)) + ()) (srwi dest src ppc64::charcode-shift)) (define-ppc64-vinsn character->fixnum (((dest :lisp)) - ((src :lisp)) - ()) + ((src :lisp)) + ()) (rlwinm dest src @@ -2177,10 +2147,10 @@ (define-ppc64-vinsn character->code (((dest :u32)) - ((src :lisp))) + ((src :lisp))) (rlwinm dest src ppc64::charcode-shift ppc64::charcode-shift ppc64::least-significant-bit)) (define-ppc64-vinsn charcode->fixnum (((dest :lisp)) - ((src :imm)) - ()) + ((src :imm)) + ()) (rlwinm dest src @@ -2190,12 +2160,12 @@ (define-ppc64-vinsn fixnum->char (((dest :lisp)) - ((src :imm)) - ()) + ((src :imm)) + ()) (rlwinm dest src (- ppc64::charcode-shift ppc64::fixnumshift) 8 (1- ppc64::charcode-shift)) (addi dest dest ppc64::subtag-character)) (define-ppc64-vinsn u8->char (((dest :lisp)) - ((src :u8)) - ()) + ((src :u8)) + ()) (rlwinm dest src ppc64::charcode-shift 8 (1- ppc64::charcode-shift)) (addi dest dest ppc64::subtag-character)) @@ -2204,69 +2174,70 @@ (define-ppc64-vinsn deref-macptr (((addr :address)) - ((src :lisp)) - ()) - (lwz addr ppc64::macptr.address src)) + ((src :lisp)) + ()) + (ld addr ppc64::macptr.address src)) (define-ppc64-vinsn set-macptr-address (() - ((addr :address) - (src :lisp)) - ()) - (stw addr ppc64::macptr.address src)) + ((addr :address) + (src :lisp)) + ()) + (std addr ppc64::macptr.address src)) (define-ppc64-vinsn macptr->heap (((dest :lisp)) - ((address :address)) - ((header :u32))) + ((address :address)) + ((header :u64))) (li header (logior (ash ppc64::macptr.element-count ppc64::num-subtag-bits) ppc64::subtag-macptr)) (la ppc::allocptr (- ppc64::fulltag-misc ppc64::macptr.size) ppc::allocptr) - (twllt ppc::allocptr ppc::allocbase) - (stw header ppc64::misc-header-offset ppc::allocptr) + (tdllt ppc::allocptr ppc::allocbase) + (std header ppc64::misc-header-offset ppc::allocptr) (mr dest ppc::allocptr) - (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits) + (rldicr ppc::allocptr ppc::allocptr 0 (- 63 ppc64::ntagbits)) ;; It's not necessary to zero out the domain/type fields, since newly ;; heap-allocated memory's guaranteed to be 0-filled. - (stw address ppc64::macptr.address dest)) + (std address ppc64::macptr.address dest)) (define-ppc64-vinsn macptr->stack (((dest :lisp)) - ((address :address)) - ((header :u32))) + ((address :address)) + ((header :u64))) (li header ppc64::macptr-header) - (stwu ppc::tsp (- (+ 8 ppc64::macptr.size)) ppc::tsp) - (stw ppc::tsp 4 ppc::tsp) - (stw header (+ 8 ppc64::fulltag-misc ppc64::macptr.header) ppc::tsp) - (stw address (+ 8 ppc64::fulltag-misc ppc64::macptr.address) ppc::tsp) + (stdu ppc::tsp (- (+ 16 ppc64::macptr.size)) ppc::tsp) + (std ppc::tsp 8 ppc::tsp) + (std header (+ 16 ppc64::fulltag-misc ppc64::macptr.header) ppc::tsp) + (std address (+ 16 ppc64::fulltag-misc ppc64::macptr.address) ppc::tsp) ;; It -is- necessary to zero out the domain/type fields here, since ;; stack-allocated memory isn't guaranteed to be 0-filled. - (stfd ppc::fp-zero (+ 8 ppc64::fulltag-misc ppc64::macptr.domain) ppc::tsp) - (la dest (+ 8 ppc64::fulltag-misc) ppc::tsp)) + (std ppc::rzero (+ 16 ppc64::fulltag-misc ppc64::macptr.domain) ppc::tsp) + (std ppc::rzero (+ 16 ppc64::fulltag-misc ppc64::macptr.type) ppc::tsp) + (la dest (+ 16 ppc64::fulltag-misc) ppc::tsp)) (define-ppc64-vinsn adjust-stack-register (() - ((reg t) - (amount :s16const))) + ((reg t) + (amount :s16const))) (la reg amount reg)) (define-ppc64-vinsn adjust-vsp (() - ((amount :s16const))) + ((amount :s16const))) (la ppc::vsp amount ppc::vsp)) ;; Arithmetic on fixnums & unboxed numbers -(define-ppc64-vinsn u32-lognot (((dest :u32)) - ((src :u32)) - ()) +(define-ppc64-vinsn u64-lognot (((dest :u64)) + ((src :u64)) + ()) (not dest src)) (define-ppc64-vinsn fixnum-lognot (((dest :imm)) - ((src :imm)) - ((temp :u32))) + ((src :imm)) + ((temp :u64))) (not temp src) - (clrrwi dest temp ppc64::nfixnumtagbits)) + (rldicr dest temp 0 (- 63 ppc64::nfixnumtagbits))) (define-ppc64-vinsn negate-fixnum-overflow-inline (((dest :lisp)) - ((src :imm)) - ((unboxed :s32) - (header :u32))) + ((src :imm)) + ((unboxed :s32) + (header :u32))) (nego. dest src) (bns+ :done) @@ -2284,6 +2255,6 @@ (define-ppc64-vinsn negate-fixnum-overflow-ool (() - ((src :imm)) - ) + ((src :imm)) + ) (nego. ppc::arg_z src) (bsola- .SPfix-overflow) @@ -2293,5 +2264,5 @@ (define-ppc64-vinsn negate-fixnum-no-ovf (((dest :lisp)) - ((src :imm))) + ((src :imm))) (neg dest src)) @@ -2299,11 +2270,11 @@ (define-ppc64-vinsn logior-high (((dest :imm)) - ((src :imm) - (high :u16const))) + ((src :imm) + (high :u16const))) (oris dest src high)) (define-ppc64-vinsn logior-low (((dest :imm)) - ((src :imm) - (low :u16const))) + ((src :imm) + (low :u16const))) (ori dest src low)) @@ -2311,36 +2282,36 @@ (define-ppc64-vinsn %logior2 (((dest :imm)) - ((x :imm) - (y :imm)) - ()) + ((x :imm) + (y :imm)) + ()) (or dest x y)) (define-ppc64-vinsn logand-high (((dest :imm)) - ((src :imm) - (high :u16const)) - ((crf0 (:crf 0)))) + ((src :imm) + (high :u16const)) + ((crf0 (:crf 0)))) (andis. dest src high)) (define-ppc64-vinsn logand-low (((dest :imm)) - ((src :imm) - (low :u16const)) - ((crf0 (:crf 0)))) + ((src :imm) + (low :u16const)) + ((crf0 (:crf 0)))) (andi. dest src low)) (define-ppc64-vinsn %logand2 (((dest :imm)) - ((x :imm) - (y :imm)) - ()) + ((x :imm) + (y :imm)) + ()) (and dest x y)) (define-ppc64-vinsn logxor-high (((dest :imm)) - ((src :imm) - (high :u16const))) + ((src :imm) + (high :u16const))) (xoris dest src high)) (define-ppc64-vinsn logxor-low (((dest :imm)) - ((src :imm) - (low :u16const))) + ((src :imm) + (low :u16const))) (xori dest src low)) @@ -2348,17 +2319,17 @@ (define-ppc64-vinsn %logxor2 (((dest :imm)) - ((x :imm) - (y :imm)) - ()) + ((x :imm) + (y :imm)) + ()) (xor dest x y)) (define-ppc64-vinsn %ilsl (((dest :imm)) - ((count :imm) - (src :imm)) - ((temp :u32) - (crx :crf))) - (cmpwi crx count (ash 31 ppc64::fixnumshift)) - (srwi temp count ppc64::fixnumshift) - (slw dest src temp) + ((count :imm) + (src :imm)) + ((temp :u32) + (crx :crf))) + (cmpdi crx count (ash 31 ppc64::fixnumshift)) + (srdi temp count ppc64::fixnumshift) + (sld dest src temp) (ble+ crx :foo) (li dest 0) @@ -2366,15 +2337,15 @@ (define-ppc64-vinsn %ilsl-c (((dest :imm)) - ((count :u8const) - (src :imm))) - ; Hard to use ppcmacroinstructions that expand into expressions involving variables. - (rlwinm dest src count 0 (:apply - ppc64::least-significant-bit count))) + ((count :u8const) + (src :imm))) + ;; Hard to use ppcmacroinstructions that expand into expressions involving variables. + (rldicr dest src count (:apply - ppc64::least-significant-bit count))) (define-ppc64-vinsn %ilsr-c (((dest :imm)) - ((count :u8const) - (src :imm))) + ((count :u8const) + (src :imm))) (rlwinm dest src (:apply - ppc64::nbits-in-word count) count (- ppc64::least-significant-bit - ppc64::fixnumshift))) + ppc64::fixnumshift))) @@ -2385,32 +2356,32 @@ (define-ppc64-vinsn %iasr (((dest :imm)) - ((count :imm) - (src :imm)) - ((temp :s32) - (crx :crf))) - (cmpwi crx count (ash 31 ppc64::fixnumshift)) - (srawi temp count ppc64::fixnumshift) - (sraw temp src temp) + ((count :imm) + (src :imm)) + ((temp :s32) + (crx :crf))) + (cmpdi crx count (ash 63 ppc64::fixnumshift)) + (sradi temp count ppc64::fixnumshift) + (srad temp src temp) (ble+ crx :foo) - (srawi temp src 31) + (sradi temp src 63) :foo - (clrrwi dest temp ppc64::fixnumshift)) + (rldicr dest temp 0 (- 63 ppc64::fixnumshift))) (define-ppc64-vinsn %iasr-c (((dest :imm)) - ((count :u8const) - (src :imm)) - ((temp :s32))) - (srawi temp src count) - (clrrwi dest temp ppc64::fixnumshift)) + ((count :u8const) + (src :imm)) + ((temp :s32))) + (sradi temp src count) + (rldicr dest temp 0 (- 63 ppc64::fixnumshift))) (define-ppc64-vinsn %ilsr (((dest :imm)) - ((count :imm) - (src :imm)) - ((temp :s32) - (crx :crf))) - (cmpwi crx count (ash 31 ppc64::fixnumshift)) - (srwi temp count ppc64::fixnumshift) - (srw temp src temp) - (clrrwi dest temp ppc64::fixnumshift) + ((count :imm) + (src :imm)) + ((temp :s32) + (crx :crf))) + (cmpdi crx count (ash 63 ppc64::fixnumshift)) + (srdi temp count ppc64::fixnumshift) + (srd temp src temp) + (rldicr dest temp 0 (- 63 ppc64::fixnumshift)) (ble+ crx :foo) (li dest 0) @@ -2419,52 +2390,46 @@ (define-ppc64-vinsn %ilsr-c (((dest :imm)) - ((count :u8const) - (src :imm)) - ((temp :s32))) + ((count :u8const) + (src :imm)) + ((temp :s32))) (rlwinm temp src (:apply - 32 count) count 31) - (clrrwi dest temp ppc64::fixnumshift)) + (rldicr dest temp 0 (- 63 ppc64::fixnumshift))) (define-ppc64-vinsn u32-shift-left (((dest :u32)) - ((src :u32) - (count :u8const))) + ((src :u32) + (count :u8const))) (rlwinm dest src count 0 (:apply - 31 count))) (define-ppc64-vinsn u32-shift-right (((dest :u32)) - ((src :u32) - (count :u8const))) + ((src :u32) + (count :u8const))) (rlwinm dest src (:apply - 32 count) count 31)) (define-ppc64-vinsn sign-extend-halfword (((dest :imm)) - ((src :imm))) - (slwi dest src (- 16 ppc64::fixnumshift)) - (srawi dest dest (- 16 ppc64::fixnumshift))) - -(define-ppc64-vinsn s32-highword (((dest :imm)) - ((src :s32)) - ((temp :s32))) - (srawi temp src 16) - (slwi dest temp ppc64::fixnumshift)) - - + ((src :imm))) + (sldi dest src (- 48 ppc64::fixnumshift)) + (sradi dest dest (- 48 ppc64::fixnumshift))) + + (define-ppc64-vinsn fixnum-add (((dest t)) - ((x t) - (y t))) + ((x t) + (y t))) (add dest x y)) (define-ppc64-vinsn fixnum-add-overflow-ool (() - ((x :imm) - (y :imm)) - ((cr0 (:crf 0)))) + ((x :imm) + (y :imm)) + ((cr0 (:crf 0)))) (addo. ppc::arg_z x y) (bsola- .SPfix-overflow)) (define-ppc64-vinsn fixnum-add-overflow-inline (((dest :lisp)) - ((x :imm) - (y :imm)) - ((cr0 (:crf 0)) - (unboxed :s32) - (header :u32))) + ((x :imm) + (y :imm)) + ((cr0 (:crf 0)) + (unboxed :s32) + (header :u32))) (addo. dest x y) (bns+ cr0 :done) @@ -2474,9 +2439,9 @@ (xoris unboxed unboxed (logand #xffff (ash #xffff (- 32 16 ppc64::fixnumshift)))) (la ppc::allocptr (- ppc64::fulltag-misc 8) ppc::allocptr) - (twllt ppc::allocptr ppc::allocbase) - (stw header ppc64::misc-header-offset ppc::allocptr) + (tdllt ppc::allocptr ppc::allocbase) + (std header ppc64::misc-header-offset ppc::allocptr) (mr dest ppc::allocptr) (clrrwi ppc::allocptr ppc::allocptr ppc64::ntagbits) - (stw unboxed ppc64::misc-data-offset dest) + (std unboxed ppc64::misc-data-offset dest) :done) @@ -2486,11 +2451,11 @@ ; (setq dest (- x y)) (define-ppc64-vinsn fixnum-sub (((dest t)) - ((x t) - (y t))) + ((x t) + (y t))) (subf dest y x)) (define-ppc64-vinsn fixnum-sub-from-constant (((dest :imm)) - ((x :s16const) - (y :imm))) + ((x :s16const) + (y :imm))) (subfic dest y (:apply ash x ppc64::fixnumshift))) @@ -2499,15 +2464,15 @@ (define-ppc64-vinsn fixnum-sub-overflow-ool (() - ((x :imm) - (y :imm))) + ((x :imm) + (y :imm))) (subo. ppc::arg_z x y) (bsola- .SPfix-overflow)) (define-ppc64-vinsn fixnum-sub-overflow-inline (((dest :lisp)) - ((x :imm) - (y :imm)) - ((cr0 (:crf 0)) - (unboxed :s32) - (header :u32))) + ((x :imm) + (y :imm)) + ((cr0 (:crf 0)) + (unboxed :s32) + (header :u32))) (subo. dest x y) (bns+ cr0 :done) @@ -2526,7 +2491,7 @@ ; This is, of course, also "subtract-immediate." (define-ppc64-vinsn add-immediate (((dest t)) - ((src t) - (upper :u32const) - (lower :u32const))) + ((src t) + (upper :u32const) + (lower :u32const))) ((:not (:pred = upper 0)) (addis dest src upper) @@ -2539,13 +2504,13 @@ ;(The one with the smaller absolute value might be) (define-ppc64-vinsn multiply-fixnums (((dest :imm)) - ((a :imm) - (b :imm)) - ((unboxed :s32))) - (srawi unboxed b ppc64::fixnumshift) - (mullw dest a unboxed)) + ((a :imm) + (b :imm)) + ((unboxed :s32))) + (sradi unboxed b ppc64::fixnumshift) + (mulld dest a unboxed)) (define-ppc64-vinsn multiply-immediate (((dest :imm)) - ((boxed :imm) - (const :s16const))) + ((boxed :imm) + (const :s16const))) (mulli dest boxed const)) @@ -2553,5 +2518,5 @@ ; should be EXACTLY = to subtag-base-char (define-ppc64-vinsn mask-base-char (((dest :u32)) - ((src :imm))) + ((src :imm))) (rlwinm dest src 0 (1+ (- ppc64::least-significant-bit ppc64::charcode-shift)) (1- (- ppc64::nbits-in-word (+ ppc64::charcode-shift 8))))) @@ -2576,13 +2541,13 @@ (define-ppc64-vinsn symbol-function (((val :lisp)) - ((sym (:lisp (:ne val)))) - ((crf :crf) - (tag :u32))) - (lwz val ppc64::symbol.fcell sym) - (clrlwi tag val (- 32 ppc64::nlisptagbits)) - (cmpwi crf tag ppc64::tag-misc) + ((sym (:lisp (:ne val)))) + ((crf :crf) + (tag :u32))) + (ld val ppc64::symbol.fcell sym) + (clrldi tag val (- 64 ppc64::ntagbits)) + (cmpdi crf tag ppc64::fulltag-misc) (bne- crf :bad) (lbz tag ppc64::misc-subtag-offset val) - (cmpwi crf tag ppc64::subtag-function) + (cmpdi crf tag ppc64::subtag-function) (beq+ crf :good) :bad @@ -2592,40 +2557,40 @@ (define-ppc64-vinsn (temp-push-unboxed-word :push :word :tsp) (() - ((w :u32))) - (stwu ppc::tsp -16 ppc::tsp) - (stw ppc::tsp 4 ppc::tsp) - (stw w 8 ppc::tsp)) + ((w :u64))) + (stdu ppc::tsp -32 ppc::tsp) + (std ppc::tsp 8 ppc::tsp) + (std w 16 ppc::tsp)) (define-ppc64-vinsn (temp-pop-unboxed-word :pop :word :tsp) - (((w :u32)) + (((w :u64)) ()) - (lwz w 8 ppc::tsp) - (lwz ppc::tsp 0 ppc::tsp)) + (ld w 16 ppc::tsp) + (ld ppc::tsp 0 ppc::tsp)) (define-ppc64-vinsn (temp-push-double-float :push :doubleword :tsp) (((d :double-float)) ()) - (stwu ppc::tsp -16 ppc::tsp) - (stw ppc::tsp 4 ppc::tsp) - (stfd d 8 ppc::tsp)) + (stdu ppc::tsp -32 ppc::tsp) + (std ppc::tsp 8 ppc::tsp) + (stfd d 16 ppc::tsp)) (define-ppc64-vinsn (temp-pop-double-float :pop :doubleword :tsp) (() ((d :double-float))) - (lfd d 8 ppc::tsp) - (lwz ppc::tsp 0 ppc::tsp)) + (lfd d 16 ppc::tsp) + (ld ppc::tsp 0 ppc::tsp)) (define-ppc64-vinsn (temp-push-single-float :push :word :tsp) (((s :single-float)) ()) - (stwu ppc::tsp -16 ppc::tsp) - (stw ppc::tsp 4 ppc::tsp) - (stfs s 8 ppc::tsp)) + (stdu ppc::tsp -32 ppc::tsp) + (std ppc::tsp 8 ppc::tsp) + (stfs s 16 ppc::tsp)) (define-ppc64-vinsn (temp-pop-single-float :pop :word :tsp) (() ((s :single-float))) - (lfs s 8 ppc::tsp) - (lwz ppc::tsp 0 ppc::tsp)) + (lfs s 16 ppc::tsp) + (ld ppc::tsp 0 ppc::tsp)) @@ -2633,32 +2598,39 @@ (() ((first :u8const))) - (stwu ppc::save0 -4 ppc::vsp) + (stdu ppc::save0 -8 ppc::vsp) ((:pred <= first ppc::save1) - (stwu ppc::save1 -4 ppc::vsp) + (stdu ppc::save1 -8 ppc::vsp) ((:pred <= first ppc::save2) - (stwu ppc::save2 -4 ppc::vsp) + (stdu ppc::save2 -8 ppc::vsp) ((:pred <= first ppc::save3) - (stwu ppc::save3 -4 ppc::vsp) - ((:pred <= first ppc::save4) - (stwu ppc::save4 -4 ppc::vsp) - ((:pred <= first ppc::save5) - (stwu ppc::save5 -4 ppc::vsp) - ((:pred <= first ppc::save6) - (stwu ppc::save6 -4 ppc::vsp) - ((:pred = first ppc::save7) - (stwu ppc::save7 -4 ppc::vsp))))))))) + (stdu ppc::save3 -8 ppc::vsp) + ((:pred <= first ppc::save4) + (stdu ppc::save4 -8 ppc::vsp) + ((:pred <= first ppc::save5) + (stdu ppc::save5 -8 ppc::vsp) + ((:pred <= first ppc::save6) + (stdu ppc::save6 -8 ppc::vsp) + ((:pred = first ppc::save7) + (stdu ppc::save7 -8 ppc::vsp))))))))) (define-ppc64-vinsn (save-nvrs :push :node :vsp :multiple) - (() - ((first :u8const))) - ((:pred <= first ppc::save3) - (subi ppc::vsp ppc::vsp (:apply * 4 (:apply - 32 first))) - (stmw first 0 ppc::vsp)) - ((:pred >= first ppc::save2) - (stwu ppc::save0 -4 ppc::vsp) - ((:pred <= first ppc::save1) - (stwu ppc::save1 -4 ppc::vsp) - ((:pred = first ppc::save2) - (stwu ppc::save2 -4 ppc::vsp))))) + (() + ((first :u8const))) + ;; There's no "stmd" instruction. + (stdu ppc::save0 -8 ppc::vsp) + ((:pred <= first ppc::save1) + (stdu ppc::save1 -8 ppc::vsp) + ((:pred <= first ppc::save2) + (stdu ppc::save2 -8 ppc::vsp) + ((:pred <= first ppc::save3) + (stdu ppc::save3 -8 ppc::vsp) + ((:pred <= first ppc::save4) + (stdu ppc::save4 -8 ppc::vsp) + ((:pred <= first ppc::save5) + (stdu ppc::save5 -8 ppc::vsp) + ((:pred <= first ppc::save6) + (stdu ppc::save6 -8 ppc::vsp) + ((:pred = first ppc::save7) + (stdu ppc::save7 -8 ppc::vsp))))))))) @@ -2668,27 +2640,60 @@ (basereg :imm) (offset :s16const))) - ((:pred <= firstreg ppc::save3) - (lmw firstreg offset basereg)) + ((:pred = firstreg ppc::save7) + (ld ppc::save7 offset basereg) + (ld ppc::save6 (:apply + offset 8) basereg) + (ld ppc::save5 (:apply + offset 16) basereg) + (ld ppc::save4 (:apply + offset 24) basereg) + (ld ppc::save3 (:apply + offset 32) basereg) + (ld ppc::save2 (:apply + offset 40) basereg) + (ld ppc::save1 (:apply + offset 48) basereg) + (ld ppc::save0 (:apply + offset 56) basereg)) + ((:pred = firstreg ppc::save6) + (ld ppc::save6 offset basereg) + (ld ppc::save5 (:apply + offset 8) basereg) + (ld ppc::save4 (:apply + offset 16) basereg) + (ld ppc::save3 (:apply + offset 24) basereg) + (ld ppc::save2 (:apply + offset 32) basereg) + (ld ppc::save1 (:apply + offset 40) basereg) + (ld ppc::save0 (:apply + offset 48) basereg)) + ((:pred = firstreg ppc::save5) + (ld ppc::save5 offset basereg) + (ld ppc::save4 (:apply + offset 8) basereg) + (ld ppc::save3 (:apply + offset 16) basereg) + (ld ppc::save2 (:apply + offset 24) basereg) + (ld ppc::save1 (:apply + offset 32) basereg) + (ld ppc::save0 (:apply + offset 40) basereg)) + ((:pred = firstreg ppc::save4) + (ld ppc::save4 offset basereg) + (ld ppc::save3 (:apply + offset 8) basereg) + (ld ppc::save2 (:apply + offset 16) basereg) + (ld ppc::save1 (:apply + offset 24) basereg) + (ld ppc::save0 (:apply + offset 32) basereg)) + ((:pred = firstreg ppc::save3) + (ld ppc::save3 offset basereg) + (ld ppc::save2 (:apply + offset 8) basereg) + (ld ppc::save1 (:apply + offset 16) basereg) + (ld ppc::save0 (:apply + offset 24) basereg)) ((:pred = firstreg ppc::save2) - (lwz ppc::save2 offset basereg) - (lwz ppc::save1 (:apply + offset 4) basereg) - (lwz ppc::save0 (:apply + offset 8) basereg)) + (ld ppc::save2 offset basereg) + (ld ppc::save1 (:apply + offset 8) basereg) + (ld ppc::save0 (:apply + offset 16) basereg)) ((:pred = firstreg ppc::save1) - (lwz ppc::save1 offset basereg) - (lwz ppc::save0 (:apply + offset 4) basereg)) + (ld ppc::save1 offset basereg) + (ld ppc::save0 (:apply + offset 8) basereg)) ((:pred = firstreg ppc::save0) - (lwz ppc::save0 offset basereg))) + (ld ppc::save0 offset basereg))) (define-ppc64-vinsn %current-frame-ptr (((dest :imm)) - ()) + ()) (mr dest ppc::sp)) (define-ppc64-vinsn %current-tcr (((dest :imm)) - ()) + ()) (mr dest ppc::rcontext)) (define-ppc64-vinsn (svar-dpayback :call :subprim-call) (() - ((n :s16const)) - ((temp (:u32 #.ppc::imm0)))) + ((n :s16const)) + ((temp (:u32 #.ppc::imm0)))) ((:pred > n 1) (li temp n) @@ -2709,12 +2714,10 @@ (define-ppc64-vinsn load-double-float-constant (((dest :double-float)) - ((high t) - (low t))) - (stwu ppc::tsp -16 ppc::tsp) - (stw ppc::tsp 4 ppc::tsp) - (stw high 8 ppc::tsp) - (stw low 12 ppc::tsp) - (lfd dest 8 ppc::tsp) - (lwz ppc::tsp 0 ppc::tsp)) + ((val t))) + (stdu ppc::tsp -32 ppc::tsp) + (std ppc::tsp 8 ppc::tsp) + (std val 16 ppc::tsp) + (lfd dest 16 ppc::tsp) + (ld ppc::tsp 0 ppc::tsp)) (define-ppc64-vinsn load-single-float-constant @@ -2728,38 +2731,38 @@ (define-ppc64-vinsn load-indexed-node (((node :lisp)) - ((base :lisp) - (offset :s16const))) - (lwz node offset base)) + ((base :lisp) + (offset :s16const))) + (ld node offset base)) (define-ppc64-vinsn recover-saved-vsp (((dest :imm)) - ()) - (lwz dest ppc64::lisp-frame.savevsp ppc::sp)) + ()) + (ld dest ppc64::lisp-frame.savevsp ppc::sp)) (define-ppc64-vinsn check-exact-nargs (() - ((n :u16const))) - (twnei ppc::nargs (:apply ash n 2))) + ((n :u16const))) + (tdnei ppc::nargs (:apply ash n ppc64::word-shift))) (define-ppc64-vinsn check-min-nargs (() - ((min :u16const))) - (twllti ppc::nargs (:apply ash min 2))) + ((min :u16const))) + (tdllti ppc::nargs (:apply ash min ppc64::word-shift))) (define-ppc64-vinsn check-max-nargs (() - ((max :u16const))) - (twlgti ppc::nargs (:apply ash max 2))) + ((max :u16const))) + (twlgti ppc::nargs (:apply ash max ppc64::word-shift))) ; Save context and establish FN. The current VSP is the the ; same as the caller's, e.g., no arguments were vpushed. (define-ppc64-vinsn save-lisp-context-vsp (() - () - ((imm :u32))) - (stwu ppc::sp (- ppc64::lisp-frame.size) ppc::sp) - (stw ppc::fn ppc64::lisp-frame.savefn ppc::sp) - (stw ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) - (stw ppc::vsp ppc64::lisp-frame.savevsp ppc::sp) + () + ((imm :u64))) + (stdu ppc::sp (- ppc64::lisp-frame.size) ppc::sp) + (std ppc::fn ppc64::lisp-frame.savefn ppc::sp) + (std ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) + (std ppc::vsp ppc64::lisp-frame.savevsp ppc::sp) (mr ppc::fn ppc::nfn) ;; Do a stack-probe ... - (lwz imm ppc64::tcr.cs-limit ppc::rcontext) - (twllt ppc::sp imm)) + (ld imm ppc64::tcr.cs-limit ppc::rcontext) + (tdllt ppc::sp imm)) ; Do the same thing via a subprim call. @@ -2767,23 +2770,23 @@ (() () - ((imm (:u32 #.ppc::imm0)))) + ((imm (:u64 #.ppc::imm0)))) (bla .SPsavecontextvsp)) (define-ppc64-vinsn save-lisp-context-offset (() - ((nbytes-vpushed :u16const)) - ((imm :u32))) + ((nbytes-vpushed :u16const)) + ((imm :u32))) (la imm nbytes-vpushed ppc::vsp) - (stwu ppc::sp (- ppc64::lisp-frame.size) ppc::sp) - (stw ppc::fn ppc64::lisp-frame.savefn ppc::sp) - (stw ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) - (stw imm ppc64::lisp-frame.savevsp ppc::sp) + (stdu ppc::sp (- ppc64::lisp-frame.size) ppc::sp) + (std ppc::fn ppc64::lisp-frame.savefn ppc::sp) + (std ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) + (std imm ppc64::lisp-frame.savevsp ppc::sp) (mr ppc::fn ppc::nfn) ;; Do a stack-probe ... - (lwz imm ppc64::tcr.cs-limit ppc::rcontext) - (twllt ppc::sp imm)) + (ld imm ppc64::tcr.cs-limit ppc::rcontext) + (tdllt ppc::sp imm)) (define-ppc64-vinsn save-lisp-context-offset-ool (() - ((nbytes-vpushed :u16const)) - ((imm (:u32 #.ppc::imm0)))) + ((nbytes-vpushed :u16const)) + ((imm (:u64 #.ppc::imm0)))) (li imm nbytes-vpushed) (bla .SPsavecontext0)) @@ -2791,23 +2794,23 @@ (define-ppc64-vinsn save-lisp-context-lexpr (() - () - ((imm :u32))) - (stwu ppc::sp (- ppc64::lisp-frame.size) ppc::sp) - (stw ppc::rzero ppc64::lisp-frame.savefn ppc::sp) - (stw ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) - (stw ppc::vsp ppc64::lisp-frame.savevsp ppc::sp) + () + ((imm :u64))) + (stdu ppc::sp (- ppc64::lisp-frame.size) ppc::sp) + (std ppc::rzero ppc64::lisp-frame.savefn ppc::sp) + (std ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) + (std ppc::vsp ppc64::lisp-frame.savevsp ppc::sp) (mr ppc::fn ppc::nfn) ;; Do a stack-probe ... - (lwz imm ppc64::tcr.cs-limit ppc::rcontext) - (twllt ppc::sp imm)) + (ld imm ppc64::tcr.cs-limit ppc::rcontext) + (tdllt ppc::sp imm)) (define-ppc64-vinsn save-cleanup-context (() - ()) + ()) ;; SP was this deep just a second ago, so no need to do a stack-probe. (mflr ppc::loc-pc) - (stwu ppc::sp (- ppc64::lisp-frame.size) ppc::sp) - (stw ppc::rzero ppc64::lisp-frame.savefn ppc::sp) - (stw ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) - (stw ppc::vsp ppc64::lisp-frame.savevsp ppc::sp)) + (stdu ppc::sp (- ppc64::lisp-frame.size) ppc::sp) + (std ppc::rzero ppc64::lisp-frame.savefn ppc::sp) + (std ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) + (std ppc::vsp ppc64::lisp-frame.savevsp ppc::sp)) ;; Vpush the argument registers. We got at least "min-fixed" args; @@ -2818,29 +2821,30 @@ ((crfx :crf) (crfy :crf) - (entry-vsp (:u32 #.ppc::imm0)) - (arg-temp :u32))) + (entry-vsp (:u64 ppc::imm0)) + (arg-temp :u64))) ((:pred >= min-fixed $numppcargregs) - (stwu ppc::arg_x -4 ppc::vsp) - (stwu ppc::arg_y -4 ppc::vsp) - (stwu ppc::arg_z -4 ppc::vsp)) + (stdu ppc::arg_x -8 ppc::vsp) + (stdu ppc::arg_y -8 ppc::vsp) + (stdu ppc::arg_z -8 ppc::vsp)) ((:pred = min-fixed 2) ; at least 2 args (cmplwi crfx ppc::nargs (ash 2 ppc64::word-shift)) (beq crfx :yz2) ; skip arg_x if exactly 2 - (stwu ppc::arg_x -4 ppc::vsp) + (stdu ppc::arg_x -8 ppc::vsp) :yz2 - (stwu ppc::arg_y -4 ppc::vsp) - (stwu ppc::arg_z -4 ppc::vsp)) + (stdu ppc::arg_y -8 + ppc::vsp) + (stdu ppc::arg_z -8 ppc::vsp)) ((:pred = min-fixed 1) ; at least one arg - (cmplwi crfx ppc::nargs (ash 2 ppc64::word-shift)) + (cmpldi crfx ppc::nargs (ash 2 ppc64::word-shift)) (blt crfx :z1) ; branch if exactly one (beq crfx :yz1) ; branch if exactly two - (stwu ppc::arg_x -4 ppc::vsp) + (stdu ppc::arg_x -8 ppc::vsp) :yz1 - (stwu ppc::arg_y -4 ppc::vsp) + (stdu ppc::arg_y -8 ppc::vsp) :z1 - (stwu ppc::arg_z -4 ppc::vsp)) + (stwu ppc::arg_z -8 ppc::vsp)) ((:pred = min-fixed 0) - (cmplwi crfx ppc::nargs (ash 2 ppc64::word-shift)) - (cmplwi crfy ppc::nargs 0) + (cmpldi crfx ppc::nargs (ash 2 ppc64::word-shift)) + (cmpldi crfy ppc::nargs 0) (beq crfx :yz0) ; exactly two (beq crfy :none) ; exactly zero @@ -2872,7 +2876,7 @@ (() ()) - (lwz ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) - (lwz ppc::vsp ppc64::lisp-frame.savevsp ppc::sp) - (lwz ppc::fn ppc64::lisp-frame.savefn ppc::sp) + (ld ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) + (ld ppc::vsp ppc64::lisp-frame.savevsp ppc::sp) + (ld ppc::fn ppc64::lisp-frame.savefn ppc::sp) (mtlr ppc::loc-pc) (la ppc::sp ppc64::lisp-frame.size ppc::sp)) @@ -2892,6 +2896,6 @@ ; (and a little simpler than) returning from a function. (define-ppc64-vinsn restore-cleanup-context (() - ()) - (lwz ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) + ()) + (ld ppc::loc-pc ppc64::lisp-frame.savelr ppc::sp) (mtlr ppc::loc-pc) (la ppc::sp ppc64::lisp-frame.size ppc::sp)) @@ -2900,10 +2904,10 @@ (define-ppc64-vinsn default-1-arg (() - ((min :u16const)) - ((crf :crf))) - (cmplwi crf ppc::nargs (:apply ash min 2)) + ((min :u16const)) + ((crf :crf))) + (cmpldi crf ppc::nargs (:apply ash min ppc64::word-shift)) (bne crf :done) ((:pred >= min 3) - (stwu ppc::arg_x -4 ppc::vsp)) + (stdu ppc::arg_x -8 ppc::vsp)) ((:pred >= min 2) (mr ppc::arg_x ppc::arg_y)) @@ -2914,14 +2918,14 @@ (define-ppc64-vinsn default-2-args (() - ((min :u16const)) - ((crf :crf))) - (cmplwi crf ppc::nargs (:apply ash (:apply 1+ min) 2)) + ((min :u16const)) + ((crf :crf))) + (cmpldi crf ppc::nargs (:apply ash (:apply 1+ min) ppc64::word-shift)) (bgt crf :done) (beq crf :one) ; We got "min" args; arg_y & arg_z default to nil ((:pred >= min 3) - (stwu ppc::arg_x -4 ppc::vsp)) + (stdu ppc::arg_x -8 ppc::vsp)) ((:pred >= min 2) - (stwu ppc::arg_y -4 ppc::vsp)) + (stdu ppc::arg_y -8 ppc::vsp)) ((:pred >= min 1) (mr ppc::arg_x ppc::arg_z)) @@ -2931,5 +2935,5 @@ ; We got min+1 args: arg_y was supplied, arg_z defaults to nil. ((:pred >= min 2) - (stwu ppc::arg_x -4 ppc::vsp)) + (stdu ppc::arg_x -8 ppc::vsp)) ((:pred >= min 1) (mr ppc::arg_x ppc::arg_y)) @@ -2940,9 +2944,9 @@ (define-ppc64-vinsn default-3-args (() - ((min :u16const)) - ((crfx :crf) - (crfy :crf))) - (cmplwi crfx ppc::nargs (:apply ash (:apply + 2 min) 2)) - (cmplwi crfy ppc::nargs (:apply ash min 2)) + ((min :u16const)) + ((crfx :crf) + (crfy :crf))) + (cmpldi crfx ppc::nargs (:apply ash (:apply + 2 min) ppc64::word-shift)) + (cmpldi crfy ppc::nargs (:apply ash min ppc64::word-shift)) (bgt crfx :done) (beq crfx :two) @@ -2950,7 +2954,7 @@ ; The first (of three) &optional args was supplied. ((:pred >= min 2) - (stwu ppc::arg_x -4 ppc::vsp)) + (stdu ppc::arg_x -8 ppc::vsp)) ((:pred >= min 1) - (stwu ppc::arg_y -4 ppc::vsp)) + (stdu ppc::arg_y -8 ppc::vsp)) (mr ppc::arg_x ppc::arg_z) (b :last-2) @@ -2958,5 +2962,5 @@ ; The first two (of three) &optional args were supplied. ((:pred >= min 1) - (stwu ppc::arg_x -4 ppc::vsp)) + (stdu ppc::arg_x -8 ppc::vsp)) (mr ppc::arg_x ppc::arg_y) (mr ppc::arg_y ppc::arg_z) @@ -2965,7 +2969,7 @@ :none ((:pred >= min 3) - (stwu ppc::arg_x -4 ppc::vsp)) + (stdu ppc::arg_x -8 ppc::vsp)) ((:pred >= min 2) - (stwu ppc::arg_y -4 ppc::vsp)) + (stdu ppc::arg_y -8 ppc::vsp)) ((:pred >= min 1) (stwu ppc::arg_z -4 ppc::vsp)) @@ -2978,5 +2982,5 @@ (define-ppc64-vinsn save-lr (() - ()) + ()) (mflr ppc::loc-pc)) @@ -2984,53 +2988,53 @@ ;; the number of &optionals. (define-ppc64-vinsn (default-optionals :call :subprim-call) (() - ((n :u16const))) - (li ppc::imm0 (:apply ash n 2)) + ((n :u16const))) + (li ppc::imm0 (:apply ash n ppc64::word-shift)) (bla .SPdefault-optional-args)) ; fname contains a known symbol (define-ppc64-vinsn (call-known-symbol :call) (((result (:lisp ppc::arg_z))) - ()) - (lwz ppc::nfn ppc64::symbol.fcell ppc::fname) - (lwz ppc::temp0 ppc64::misc-data-offset ppc::nfn) + ()) + (ld ppc::nfn ppc64::symbol.fcell ppc::fname) + (ld ppc::temp0 ppc64::misc-data-offset ppc::nfn) (mtctr ppc::temp0) (bctrl)) (define-ppc64-vinsn (jump-known-symbol :jumplr) (() - ()) - (lwz ppc::nfn ppc64::symbol.fcell ppc::fname) - (lwz ppc::temp0 ppc64::misc-data-offset ppc::nfn) + ()) + (ld ppc::nfn ppc64::symbol.fcell ppc::fname) + (ld ppc::temp0 ppc64::misc-data-offset ppc::nfn) (mtctr ppc::temp0) (bctr)) (define-ppc64-vinsn (call-known-function :call) (() - ()) - (lwz ppc::temp0 ppc64::misc-data-offset ppc::nfn) + ()) + (ld ppc::temp0 ppc64::misc-data-offset ppc::nfn) (mtctr ppc::temp0) (bctrl)) (define-ppc64-vinsn (jump-known-function :jumplr) (() - ()) - (lwz ppc::temp0 ppc64::misc-data-offset ppc::nfn) + ()) + (ld ppc::temp0 ppc64::misc-data-offset ppc::nfn) (mtctr ppc::temp0) (bctr)) (define-ppc64-vinsn %schar (((char :imm)) - ((str :lisp) - (idx :imm)) - ((imm :u32) - (cr0 (:crf 0)))) - (srwi imm idx ppc64::fixnumshift) + ((str :lisp) + (idx :imm)) + ((imm :u32) + (cr0 (:crf 0)))) + (srdi imm idx ppc64::fixnumshift) (addi imm imm ppc64::misc-data-offset) (lbzx imm str imm) - (rlwinm imm imm ppc64::charcode-shift 8 (1- ppc64::charcode-shift)) + (rldicr imm imm ppc64::charcode-shift (- 63 ppc64::charcode-shift)) (addi char imm ppc64::subtag-character)) (define-ppc64-vinsn %set-schar (() - ((str :lisp) - (idx :imm) - (char :imm)) - ((imm :u32) - (imm1 :u32) - (cr0 (:crf 0)))) + ((str :lisp) + (idx :imm) + (char :imm)) + ((imm :u64) + (imm1 :u64) + (cr0 (:crf 0)))) (srwi imm idx ppc64::fixnumshift) (addi imm imm ppc64::misc-data-offset) @@ -3040,10 +3044,10 @@ (define-ppc64-vinsn %set-scharcode (() - ((str :lisp) - (idx :imm) - (code :imm)) - ((imm :u32) - (imm1 :u32) - (cr0 (:crf 0)))) + ((str :lisp) + (idx :imm) + (code :imm)) + ((imm :u32) + (imm1 :u32) + (cr0 (:crf 0)))) (srwi imm idx ppc64::fixnumshift) (addi imm imm ppc64::misc-data-offset) @@ -3054,8 +3058,8 @@ (define-ppc64-vinsn %scharcode (((code :imm)) - ((str :lisp) - (idx :imm)) - ((imm :u32) - (cr0 (:crf 0)))) + ((str :lisp) + (idx :imm)) + ((imm :u32) + (cr0 (:crf 0)))) (srwi imm idx ppc64::fixnumshift) (addi imm imm ppc64::misc-data-offset) @@ -3065,5 +3069,5 @@ ; Clobbers LR (define-ppc64-vinsn (%debug-trap :call :subprim-call) (() - ()) + ()) (bla .SPbreakpoint) ) @@ -3071,30 +3075,30 @@ (define-ppc64-vinsn eep.address (((dest t)) - ((src (:lisp (:ne dest ))))) + ((src (:lisp (:ne dest ))))) (lwz dest (+ (ash 1 2) ppc64::misc-data-offset) src) (tweqi dest ppc64::nil-value)) (define-ppc64-vinsn %u32+ (((dest :u32)) - ((x :u32) (y :u32))) + ((x :u32) (y :u32))) (add dest x y)) (define-ppc64-vinsn %u32+-c (((dest :u32)) - ((x :u32) (y :u16const))) + ((x :u32) (y :u16const))) (addi dest x y)) (define-ppc64-vinsn %u32- (((dest :u32)) - ((x :u32) (y :u32))) + ((x :u32) (y :u32))) (sub dest x y)) (define-ppc64-vinsn %u32--c (((dest :u32)) - ((x :u32) (y :u16const))) + ((x :u32) (y :u16const))) (subi dest x y)) (define-ppc64-vinsn %u32-logior (((dest :u32)) - ((x :u32) (y :u32))) + ((x :u32) (y :u32))) (or dest x y)) (define-ppc64-vinsn %u32-logior-c (((dest :u32)) - ((x :u32) (high :u16const) (low :u16const))) + ((x :u32) (high :u16const) (low :u16const))) ((:not (:pred = high 0)) (oris dest x high)) @@ -3103,9 +3107,9 @@ (define-ppc64-vinsn %u32-logxor (((dest :u32)) - ((x :u32) (y :u32))) + ((x :u32) (y :u32))) (xor dest x y)) (define-ppc64-vinsn %u32-logxor-c (((dest :u32)) - ((x :u32) (high :u16const) (low :u16const))) + ((x :u32) (high :u16const) (low :u16const))) ((:not (:pred = high 0)) (xoris dest x high)) @@ -3114,26 +3118,26 @@ (define-ppc64-vinsn %u32-logand (((dest :u32)) - ((x :u32) (y :u32))) + ((x :u32) (y :u32))) (and dest x y)) (define-ppc64-vinsn %u32-logand-high-c (((dest :u32)) - ((x :u32) (high :u16const)) - ((cr0 (:crf 0)))) + ((x :u32) (high :u16const)) + ((cr0 (:crf 0)))) (andis. dest x high)) (define-ppc64-vinsn %u32-logand-low-c (((dest :u32)) - ((x :u32) (low :u16const)) - ((cr0 (:crf 0)))) + ((x :u32) (low :u16const)) + ((cr0 (:crf 0)))) (andi. dest x low)) (define-ppc64-vinsn %u32-logand-mask-c (((dest :u32)) - ((x :u32) - (start :u8const) - (end :u8const))) + ((x :u32) + (start :u8const) + (end :u8const))) (rlwinm dest x 0 start end)) (define-ppc64-vinsn disable-interrupts (((dest :lisp)) - () - ((temp :imm))) + () + ((temp :imm))) (li temp -4) (lwz dest ppc64::tcr.interrupt-level ppc::rcontext) @@ -3260,5 +3264,5 @@ (define-ppc64-vinsn (nth-value :call :subprim-call) (((result :lisp)) - ()) + ()) (bla .SPnthvalue)) @@ -3276,5 +3280,5 @@ ;;; transfer & jump ...) (define-ppc64-vinsn (throw :jump :jump-unknown) (() - ()) + ()) (bla .SPthrow)) @@ -3316,10 +3320,10 @@ (define-ppc64-vinsn (darwin-syscall :call :subprim-call) (() - ()) + ()) (stw ppc::rzero ppc64::c-frame.crsave ppc::sp) (bla .SPdarwin-syscall)) (define-ppc64-vinsn (darwin-syscall-s64 :call :subprim-call) (() - ()) + ()) (stw ppc::sp ppc64::c-frame.crsave ppc::sp) (bla .SPdarwin-syscall))