Index: /trunk/ccl/compiler/PPC/ppc-vinsns.lisp =================================================================== --- /trunk/ccl/compiler/PPC/ppc-vinsns.lisp (revision 254) +++ /trunk/ccl/compiler/PPC/ppc-vinsns.lisp (revision 255) @@ -25,5 +25,5 @@ (require "PPCENV")) -(defmacro define-ppc-vinsn (vinsn-name (results args &optional temps) &body body) +(defmacro define-ppc32-vinsn (vinsn-name (results args &optional temps) &body body) (%define-vinsn *ppc-backend* vinsn-name results args temps body)) @@ -31,5 +31,5 @@ ; Index "scaling" and constant-offset misc-ref vinsns. -(define-ppc-vinsn scale-32bit-misc-index (((dest :u32)) +(define-ppc32-vinsn scale-32bit-misc-index (((dest :u32)) ((idx :imm) ; A fixnum ) @@ -37,5 +37,5 @@ (addi dest idx ppc32::misc-data-offset)) -(define-ppc-vinsn scale-16bit-misc-index (((dest :u32)) +(define-ppc32-vinsn scale-16bit-misc-index (((dest :u32)) ((idx :imm) ; A fixnum ) @@ -44,5 +44,5 @@ (addi dest dest ppc32::misc-data-offset)) -(define-ppc-vinsn scale-8bit-misc-index (((dest :u32)) +(define-ppc32-vinsn scale-8bit-misc-index (((dest :u32)) ((idx :imm) ; A fixnum ) @@ -51,5 +51,5 @@ (addi dest dest ppc32::misc-data-offset)) -(define-ppc-vinsn scale-64bit-misc-index (((dest :u32)) +(define-ppc32-vinsn scale-64bit-misc-index (((dest :u32)) ((idx :imm) ; A fixnum ) @@ -58,5 +58,5 @@ (addi dest dest ppc32::misc-dfloat-offset)) -(define-ppc-vinsn scale-1bit-misc-index (((word-index :u32) +(define-ppc32-vinsn scale-1bit-misc-index (((word-index :u32) (bitnum :u8)) ; (unsigned-byte 5) ((idx :imm) ; A fixnum @@ -74,5 +74,5 @@ -(define-ppc-vinsn misc-ref-u32 (((dest :u32)) +(define-ppc32-vinsn misc-ref-u32 (((dest :u32)) ((v :lisp) (scaled-idx :u32)) @@ -80,5 +80,5 @@ (lwzx dest v scaled-idx)) -(define-ppc-vinsn misc-ref-c-u32 (((dest :u32)) +(define-ppc32-vinsn misc-ref-c-u32 (((dest :u32)) ((v :lisp) (idx :u32const)) @@ -86,5 +86,5 @@ (lwz dest (:apply + ppc32::misc-data-offset (:apply ash idx 2)) v)) -(define-ppc-vinsn misc-ref-s32 (((dest :s32)) +(define-ppc32-vinsn misc-ref-s32 (((dest :s32)) ((v :lisp) (scaled-idx :u32)) @@ -92,5 +92,5 @@ (lwzx dest v scaled-idx)) -(define-ppc-vinsn misc-ref-c-s32 (((dest :s32)) +(define-ppc32-vinsn misc-ref-c-s32 (((dest :s32)) ((v :lisp) (idx :u32const)) @@ -99,5 +99,5 @@ -(define-ppc-vinsn misc-set-c-u32 (() +(define-ppc32-vinsn misc-set-c-u32 (() ((val :u32) (v :lisp) @@ -105,5 +105,5 @@ (stw val (:apply + ppc32::misc-data-offset (:apply ash idx 2)) v)) -(define-ppc-vinsn misc-set-u32 (() +(define-ppc32-vinsn misc-set-u32 (() ((val :u32) (v :lisp) @@ -112,5 +112,5 @@ -(define-ppc-vinsn misc-ref-single-float (((dest :single-float)) +(define-ppc32-vinsn misc-ref-single-float (((dest :single-float)) ((v :lisp) (scaled-idx :u32)) @@ -118,5 +118,5 @@ (lfsx dest v scaled-idx)) -(define-ppc-vinsn misc-ref-c-single-float (((dest :single-float)) +(define-ppc32-vinsn misc-ref-c-single-float (((dest :single-float)) ((v :lisp) (idx :u32const)) @@ -124,5 +124,5 @@ (lfs dest (:apply + ppc32::misc-data-offset (:apply ash idx 2)) v)) -(define-ppc-vinsn misc-ref-double-float (((dest :double-float)) +(define-ppc32-vinsn misc-ref-double-float (((dest :double-float)) ((v :lisp) (scaled-idx :u32)) @@ -131,5 +131,5 @@ -(define-ppc-vinsn misc-ref-c-double-float (((dest :double-float)) +(define-ppc32-vinsn misc-ref-c-double-float (((dest :double-float)) ((v :lisp) (idx :u32const)) @@ -137,10 +137,10 @@ (lfd dest (:apply + ppc32::misc-dfloat-offset (:apply ash idx 3)) v)) -(define-ppc-vinsn misc-set-c-double-float (((val :double-float)) +(define-ppc32-vinsn misc-set-c-double-float (((val :double-float)) ((v :lisp) (idx :u32const))) (stfd val (:apply + ppc32::misc-dfloat-offset (:apply ash idx 3)) v)) -(define-ppc-vinsn misc-set-double-float (() +(define-ppc32-vinsn misc-set-double-float (() ((val :double-float) (v :lisp) @@ -148,10 +148,10 @@ (stfdx val v scaled-idx)) -(define-ppc-vinsn misc-set-c-single-float (((val :single-float)) +(define-ppc32-vinsn misc-set-c-single-float (((val :single-float)) ((v :lisp) (idx :u32const))) (stfs val (:apply + ppc32::misc-data-offset (:apply ash idx 2)) v)) -(define-ppc-vinsn misc-set-single-float (() +(define-ppc32-vinsn misc-set-single-float (() ((val :single-float) (v :lisp) @@ -160,5 +160,5 @@ -(define-ppc-vinsn misc-ref-u16 (((dest :u16)) +(define-ppc32-vinsn misc-ref-u16 (((dest :u16)) ((v :lisp) (scaled-idx :u32)) @@ -166,5 +166,5 @@ (lhzx dest v scaled-idx)) -(define-ppc-vinsn misc-ref-c-u16 (((dest :u16)) +(define-ppc32-vinsn misc-ref-c-u16 (((dest :u16)) ((v :lisp) (idx :u32const)) @@ -172,5 +172,5 @@ (lhz dest (:apply + ppc32::misc-data-offset (:apply ash idx 1)) v)) -(define-ppc-vinsn misc-set-c-u16 (((val :u16)) +(define-ppc32-vinsn misc-set-c-u16 (((val :u16)) ((v :lisp) (idx :u32const)) @@ -178,10 +178,10 @@ (sth val (:apply + ppc32::misc-data-offset (:apply ash idx 1)) v)) -(define-ppc-vinsn misc-set-u16 (((val :u16)) +(define-ppc32-vinsn misc-set-u16 (((val :u16)) ((v :lisp) (scaled-idx :s32))) (sthx val v scaled-idx)) -(define-ppc-vinsn misc-ref-s16 (((dest :s16)) +(define-ppc32-vinsn misc-ref-s16 (((dest :s16)) ((v :lisp) (scaled-idx :u32)) @@ -189,5 +189,5 @@ (lhax dest v scaled-idx)) -(define-ppc-vinsn misc-ref-c-s16 (((dest :s16)) +(define-ppc32-vinsn misc-ref-c-s16 (((dest :s16)) ((v :lisp) (idx :u32const)) @@ -195,5 +195,5 @@ (lha dest (:apply + ppc32::misc-data-offset (:apply ash idx 1)) v)) -(define-ppc-vinsn misc-ref-u8 (((dest :u8)) +(define-ppc32-vinsn misc-ref-u8 (((dest :u8)) ((v :lisp) (scaled-idx :u32)) @@ -201,5 +201,5 @@ (lbzx dest v scaled-idx)) -(define-ppc-vinsn misc-ref-c-u8 (((dest :u8)) +(define-ppc32-vinsn misc-ref-c-u8 (((dest :u8)) ((v :lisp) (idx :u32const)) @@ -207,5 +207,5 @@ (lbz dest (:apply + ppc32::misc-data-offset idx) v)) -(define-ppc-vinsn misc-set-c-u8 (((val :u8)) +(define-ppc32-vinsn misc-set-c-u8 (((val :u8)) ((v :lisp) (idx :u32const)) @@ -213,5 +213,5 @@ (stb val (:apply + ppc32::misc-data-offset idx) v)) -(define-ppc-vinsn misc-set-u8 (((val :u8)) +(define-ppc32-vinsn misc-set-u8 (((val :u8)) ((v :lisp) (scaled-idx :u32)) @@ -219,5 +219,5 @@ (stbx val v scaled-idx)) -(define-ppc-vinsn misc-ref-s8 (((dest :s8)) +(define-ppc32-vinsn misc-ref-s8 (((dest :s8)) ((v :lisp) (scaled-idx :u32)) @@ -226,5 +226,5 @@ (extsb dest dest)) -(define-ppc-vinsn misc-ref-c-s8 (((dest :s8)) +(define-ppc32-vinsn misc-ref-c-s8 (((dest :s8)) ((v :lisp) (idx :u32const)) @@ -234,5 +234,5 @@ -(define-ppc-vinsn misc-ref-c-bit (((dest :u8)) +(define-ppc32-vinsn misc-ref-c-bit (((dest :u8)) ((v :lisp) (idx :u32const)) @@ -241,5 +241,5 @@ (rlwinm dest dest (:apply 1+ (:apply logand idx #x1f)) 31 31)) -(define-ppc-vinsn misc-ref-c-bit[fixnum] (((dest :imm)) +(define-ppc32-vinsn misc-ref-c-bit-fixnum (((dest :imm)) ((v :lisp) (idx :u32const)) @@ -253,5 +253,5 @@ -(define-ppc-vinsn misc-ref-node (((dest :lisp)) +(define-ppc32-vinsn misc-ref-node (((dest :lisp)) ((v :lisp) (scaled-idx :s32)) @@ -259,5 +259,5 @@ (lwzx dest v scaled-idx)) -(define-ppc-vinsn misc-set-node (() +(define-ppc32-vinsn misc-set-node (() ((val :lisp) (v :lisp) @@ -269,5 +269,5 @@ -(define-ppc-vinsn misc-ref-c-node (((dest :lisp)) +(define-ppc32-vinsn misc-ref-c-node (((dest :lisp)) ((v :lisp) (idx :s16const)) @@ -275,5 +275,5 @@ (lwz dest (:apply + ppc32::misc-data-offset (:apply ash idx 2)) v)) -(define-ppc-vinsn misc-set-c-node (() +(define-ppc32-vinsn misc-set-c-node (() ((val :lisp) (v :lisp) @@ -283,5 +283,5 @@ -(define-ppc-vinsn misc-element-count[fixnum] (((dest :imm)) +(define-ppc32-vinsn misc-element-count-fixnum (((dest :imm)) ((v :lisp)) ((temp :u32))) @@ -293,5 +293,5 @@ (- ppc32::least-significant-bit ppc32::fixnumshift))) -(define-ppc-vinsn check-misc-bound (() +(define-ppc32-vinsn check-misc-bound (() ((idx :imm) (v :lisp)) @@ -305,5 +305,5 @@ (twlge idx temp)) -(define-ppc-vinsn 2d-unscaled-index (((dest :u32)) +(define-ppc32-vinsn 2d-unscaled-index (((dest :u32)) ((array :lisp) (i :imm) @@ -315,5 +315,5 @@ -(define-ppc-vinsn 2d-32-scaled-index (((dest :u32)) +(define-ppc32-vinsn 2d-32-scaled-index (((dest :u32)) ((array :lisp) (i :imm) @@ -324,5 +324,5 @@ (la dest ppc32::misc-data-offset dest)) -(define-ppc-vinsn 2d-dim1 (((dest :u32)) +(define-ppc32-vinsn 2d-dim1 (((dest :u32)) ((header :lisp))) (lwz dest (+ ppc32::misc-data-offset (* 4 (1+ ppc32::arrayH.dim0-cell))) header) @@ -330,5 +330,5 @@ ;; Return dim1 (unboxed) -(define-ppc-vinsn check-2d-bound (((dim :u32)) +(define-ppc32-vinsn check-2d-bound (((dim :u32)) ((i :imm) (j :imm) @@ -340,10 +340,10 @@ (srawi dim dim ppc32::fixnumshift)) -(define-ppc-vinsn array-data-vector-ref (((dest :lisp)) +(define-ppc32-vinsn array-data-vector-ref (((dest :lisp)) ((header :lisp))) (lwz dest ppc32::arrayH.data-vector header)) -(define-ppc-vinsn check-arrayH-rank (() +(define-ppc32-vinsn check-arrayH-rank (() ((header :lisp) (expected :u32const)) @@ -352,5 +352,5 @@ (twi 27 rank (:apply ash expected ppc32::fixnumshift))) -(define-ppc-vinsn check-arrayH-flags (() +(define-ppc32-vinsn check-arrayH-flags (() ((header :lisp) (expected :u16const)) @@ -363,42 +363,8 @@ -(define-ppc-vinsn misc-element-count[u32] (((dest :u32)) - ((v :lisp)) - ()) - (lwz dest ppc32::misc-header-offset v) - (srwi dest dest ppc32::num-subtag-bits)) - -(define-ppc-vinsn misc-subtag[fixnum] (((dest :imm)) - ((v :lisp)) - ((temp :u32))) - (lbz temp ppc32::misc-subtag-offset v) - (slwi dest temp ppc32::fixnumshift)) - -(define-ppc-vinsn misc-subtag[u32] (((dest :u32)) - ((v :lisp)) - ()) - (lbz dest ppc32::misc-subtag-offset v)) - -(define-ppc-vinsn header->subtag[u32] (((dest :u32)) - ((header :u32)) - ()) - (clrlwi dest header (- ppc32::nbits-in-word ppc32::num-subtag-bits))) - -(define-ppc-vinsn header->subtag[fixnum] (((dest :imm)) - ((header :u32)) - ()) - (rlwinm dest - header - ppc32::fixnumshift - (- ppc32::nbits-in-word (+ ppc32::nfixnumtagbits ppc32::num-subtag-bits)) - (- ppc32::least-significant-bit ppc32::nfixnumtagbits))) - -(define-ppc-vinsn header->element-count[u32] (((dest :u32)) - ((header :u32)) - ()) - (srwi dest header ppc32::num-subtag-bits)) + -(define-ppc-vinsn node-slot-ref (((dest :lisp)) +(define-ppc32-vinsn node-slot-ref (((dest :lisp)) ((node :lisp) (cellno :u32const))) @@ -407,5 +373,5 @@ -(define-ppc-vinsn %slot-ref (((dest :lisp)) +(define-ppc32-vinsn %slot-ref (((dest :lisp)) ((instance (:lisp (:ne dest))) (index :lisp)) @@ -418,20 +384,20 @@ ; Untagged memory reference & assignment. -(define-ppc-vinsn mem-ref-c-fullword (((dest :u32)) +(define-ppc32-vinsn mem-ref-c-fullword (((dest :u32)) ((src :address) (index :s16const))) (lwz dest index src)) -(define-ppc-vinsn mem-ref-fullword (((dest :u32)) +(define-ppc32-vinsn mem-ref-fullword (((dest :u32)) ((src :address) (index :s32))) (lwzx dest src index)) -(define-ppc-vinsn mem-ref-c-u16 (((dest :u16)) +(define-ppc32-vinsn mem-ref-c-u16 (((dest :u16)) ((src :address) (index :s16const))) (lhz dest index src)) -(define-ppc-vinsn mem-ref-u16 (((dest :u16)) +(define-ppc32-vinsn mem-ref-u16 (((dest :u16)) ((src :address) (index :s32))) @@ -439,25 +405,25 @@ -(define-ppc-vinsn mem-ref-c-s16 (((dest :s16)) +(define-ppc32-vinsn mem-ref-c-s16 (((dest :s16)) ((src :address) (index :s16const))) (lha dest src index)) -(define-ppc-vinsn mem-ref-s16 (((dest :s16)) +(define-ppc32-vinsn mem-ref-s16 (((dest :s16)) ((src :address) (index :s32))) (lhax dest src index)) -(define-ppc-vinsn mem-ref-c-u8 (((dest :u8)) +(define-ppc32-vinsn mem-ref-c-u8 (((dest :u8)) ((src :address) (index :s16const))) (lbz dest index src)) -(define-ppc-vinsn mem-ref-u8 (((dest :u8)) +(define-ppc32-vinsn mem-ref-u8 (((dest :u8)) ((src :address) (index :s32))) (lbzx dest src index)) -(define-ppc-vinsn mem-ref-c-s8 (((dest :s8)) +(define-ppc32-vinsn mem-ref-c-s8 (((dest :s8)) ((src :address) (index :s16const))) @@ -465,5 +431,5 @@ (extsb dest dest)) -(define-ppc-vinsn mem-ref-s8 (((dest :s8)) +(define-ppc32-vinsn mem-ref-s8 (((dest :s8)) ((src :address) (index :s32))) @@ -471,5 +437,5 @@ (extsb dest dest)) -(define-ppc-vinsn mem-ref-c-bit (((dest :u8)) +(define-ppc32-vinsn mem-ref-c-bit (((dest :u8)) ((src :address) (byte-index :s16const) @@ -478,5 +444,5 @@ (rlwinm dest dest bit-shift 31 31)) -(define-ppc-vinsn mem-ref-c-bit[fixnum] (((dest :lisp)) +(define-ppc32-vinsn mem-ref-c-bit-fixnum (((dest :lisp)) ((src :address) (byte-index :s16const) @@ -486,5 +452,5 @@ (rlwinm dest byteval bit-shift 29 29)) -(define-ppc-vinsn mem-ref-bit (((dest :u8)) +(define-ppc32-vinsn mem-ref-bit (((dest :u8)) ((src :address) (bit-index :lisp)) @@ -498,5 +464,5 @@ -(define-ppc-vinsn mem-ref-bit[fixnum] (((dest :lisp)) +(define-ppc32-vinsn mem-ref-bit-fixnum (((dest :lisp)) ((src :address) (bit-index :lisp)) @@ -513,15 +479,15 @@ (- ppc32::least-significant-bit ppc32::fixnum-shift))) -(define-ppc-vinsn mem-ref-c-double-float (((dest :double-float)) +(define-ppc32-vinsn mem-ref-c-double-float (((dest :double-float)) ((src :address) (index :s16const))) (lfd dest index src)) -(define-ppc-vinsn mem-ref-double-float (((dest :double-float)) +(define-ppc32-vinsn mem-ref-double-float (((dest :double-float)) ((src :address) (index :s32))) (lfdx dest src index)) -(define-ppc-vinsn mem-set-c-double-float (() +(define-ppc32-vinsn mem-set-c-double-float (() ((val :double-float) (src :address) @@ -529,5 +495,5 @@ (stfd val index src)) -(define-ppc-vinsn mem-set-double-float (() +(define-ppc32-vinsn mem-set-double-float (() ((val :double-float) (src :address) @@ -535,15 +501,15 @@ (stfdx val src index)) -(define-ppc-vinsn mem-ref-c-single-float (((dest :single-float)) +(define-ppc32-vinsn mem-ref-c-single-float (((dest :single-float)) ((src :address) (index :s16const))) (lfs dest index src)) -(define-ppc-vinsn mem-ref-single-float (((dest :single-float)) +(define-ppc32-vinsn mem-ref-single-float (((dest :single-float)) ((src :address) (index :s32))) (lfsx dest src index)) -(define-ppc-vinsn mem-set-c-single-float (() +(define-ppc32-vinsn mem-set-c-single-float (() ((val :single-float) (src :address) @@ -551,5 +517,5 @@ (stfs val index src)) -(define-ppc-vinsn mem-set-single-float (() +(define-ppc32-vinsn mem-set-single-float (() ((val :single-float) (src :address) @@ -558,5 +524,5 @@ -(define-ppc-vinsn mem-set-c-fullword (() +(define-ppc32-vinsn mem-set-c-fullword (() ((val :u32) (src :address) @@ -564,5 +530,5 @@ (stw val index src)) -(define-ppc-vinsn mem-set-fullword (() +(define-ppc32-vinsn mem-set-fullword (() ((val :u32) (src :address) @@ -570,5 +536,5 @@ (stwx val src index)) -(define-ppc-vinsn mem-set-c-halfword (() +(define-ppc32-vinsn mem-set-c-halfword (() ((val :u16) (src :address) @@ -576,5 +542,5 @@ (sth val index src)) -(define-ppc-vinsn mem-set-halfword (() +(define-ppc32-vinsn mem-set-halfword (() ((val :u16) (src :address) @@ -582,5 +548,5 @@ (sthx val src index)) -(define-ppc-vinsn mem-set-c-byte (() +(define-ppc32-vinsn mem-set-c-byte (() ((val :u16) (src :address) @@ -588,5 +554,5 @@ (stb val index src)) -(define-ppc-vinsn mem-set-byte (() +(define-ppc32-vinsn mem-set-byte (() ((val :u8) (src :address) @@ -594,5 +560,5 @@ (stbx val src index)) -(define-ppc-vinsn mem-set-c-bit-0 (() +(define-ppc32-vinsn mem-set-c-bit-0 (() ((src :address) (byte-index :s16const) @@ -604,5 +570,5 @@ (stb val byte-index src)) -(define-ppc-vinsn mem-set-c-bit-1 (() +(define-ppc32-vinsn mem-set-c-bit-1 (() ((src :address) (byte-index :s16const) @@ -613,5 +579,5 @@ (stb val byte-index src)) -(define-ppc-vinsn mem-set-c-bit (() +(define-ppc32-vinsn mem-set-c-bit (() ((src :address) (byte-index :s16const) @@ -625,5 +591,5 @@ ;;; Hey, they should be happy that it even works. Who cares how big it is or how ;;; long it takes ... -(define-ppc-vinsn mem-set-bit (() +(define-ppc32-vinsn mem-set-bit (() ((src :address) (bit-index :lisp) @@ -653,10 +619,10 @@ ; Tag and subtag extraction, comparison, checking, trapping ... -(define-ppc-vinsn extract-tag (((tag :u8)) +(define-ppc32-vinsn extract-tag (((tag :u8)) ((object :lisp)) ()) (clrlwi tag object (- ppc32::nbits-in-word ppc32::nlisptagbits))) -(define-ppc-vinsn extract-tag[fixnum] (((tag :imm)) +(define-ppc32-vinsn extract-tag-fixnum (((tag :imm)) ((object :lisp))) (rlwinm tag @@ -667,5 +633,5 @@ (- ppc32::least-significant-bit ppc32::fixnum-shift))) -(define-ppc-vinsn extract-fulltag (((tag :u8)) +(define-ppc32-vinsn extract-fulltag (((tag :u8)) ((object :lisp)) ()) @@ -673,5 +639,5 @@ -(define-ppc-vinsn extract-fulltag[fixnum] (((tag :imm)) +(define-ppc32-vinsn extract-fulltag-fixnum (((tag :imm)) ((object :lisp))) (rlwinm tag @@ -682,5 +648,5 @@ (- ppc32::least-significant-bit ppc32::fixnum-shift))) -(define-ppc-vinsn extract-typecode (((code :u8)) +(define-ppc32-vinsn extract-typecode (((code :u8)) ((object :lisp)) ((crf :crf))) @@ -691,5 +657,5 @@ :not-misc) -(define-ppc-vinsn extract-typecode[fixnum] (((code :imm)) +(define-ppc32-vinsn extract-typecode-fixnum (((code :imm)) ((object (:lisp (:ne code)))) ((crf :crf) (subtag :u8))) @@ -707,5 +673,5 @@ -(define-ppc-vinsn require-fixnum (() +(define-ppc32-vinsn require-fixnum (() ((object :lisp)) ((crf0 (:crf 0)) @@ -718,5 +684,5 @@ :got-it) -(define-ppc-vinsn require-integer (() +(define-ppc32-vinsn require-integer (() ((object :lisp)) ((crf0 (:crf 0)) @@ -735,5 +701,5 @@ :got-it) -(define-ppc-vinsn require-simple-vector (() +(define-ppc32-vinsn require-simple-vector (() ((object :lisp)) ((tag :u8) @@ -751,5 +717,5 @@ :got-it) -(define-ppc-vinsn require-simple-string (() +(define-ppc32-vinsn require-simple-string (() ((object :lisp)) ((tag :u8) @@ -771,5 +737,5 @@ -(define-ppc-vinsn require-real (() +(define-ppc32-vinsn require-real (() ((object :lisp)) ((crf0 (:crf 0)) @@ -788,5 +754,5 @@ :got-it) -(define-ppc-vinsn require-number (() +(define-ppc32-vinsn require-number (() ((object :lisp)) ((crf0 (:crf 0)) @@ -806,5 +772,5 @@ -(define-ppc-vinsn require-list (() +(define-ppc32-vinsn require-list (() ((object :lisp)) ((tag :u8) @@ -818,5 +784,5 @@ :got-it) -(define-ppc-vinsn require-symbol (() +(define-ppc32-vinsn require-symbol (() ((object :lisp)) ((tag :u8) @@ -836,5 +802,5 @@ :got-it) -(define-ppc-vinsn require-character (() +(define-ppc32-vinsn require-character (() ((object :lisp)) ((tag :u8) @@ -849,5 +815,5 @@ -(define-ppc-vinsn require-u8 (() +(define-ppc32-vinsn require-u8 (() ((object :lisp)) ((crf0 (:crf 0)) @@ -861,13 +827,13 @@ :got-it) -(define-ppc-vinsn box-fixnum (((dest :imm)) +(define-ppc32-vinsn box-fixnum (((dest :imm)) ((src :s32))) (slwi dest src ppc32::fixnumshift)) -(define-ppc-vinsn fixnum->s32 (((dest :s32)) +(define-ppc32-vinsn fixnum->s32 (((dest :s32)) ((src :imm))) (srawi dest src ppc32::fixnumshift)) -(define-ppc-vinsn fixnum->u32 (((dest :u32)) +(define-ppc32-vinsn fixnum->u32 (((dest :u32)) ((src :imm))) (srwi dest src ppc32::fixnumshift)) @@ -878,5 +844,5 @@ ; c) it's a bignum of length 2 and the sign-digit is 0. -(define-ppc-vinsn unbox-u32 (((dest :u32)) +(define-ppc32-vinsn unbox-u32 (((dest :u32)) ((src :lisp)) ((crf0 (:crf 0)) @@ -909,5 +875,5 @@ ; b) it's a bignum with exactly one digit. -(define-ppc-vinsn unbox-s32 (((dest :s32)) +(define-ppc32-vinsn unbox-s32 (((dest :s32)) ((src :lisp)) ((crfx :crf) @@ -931,5 +897,5 @@ ; Return dest if src is either (signed-byte 32) or (unsigned-byte 32). ; Say that it's not (signed-byte 32) if neither. -(define-ppc-vinsn unbox-x32 (((dest :u32)) +(define-ppc32-vinsn unbox-x32 (((dest :u32)) ((src :lisp)) ((crfx :crf) @@ -955,5 +921,5 @@ :got-it) -(define-ppc-vinsn unbox-u16 (((dest :u16)) +(define-ppc32-vinsn unbox-u16 (((dest :u16)) ((src :lisp)) ((crf0 (:crf 0)))) @@ -965,5 +931,5 @@ :got-it) -(define-ppc-vinsn unbox-s16 (((dest :s16)) +(define-ppc32-vinsn unbox-s16 (((dest :s16)) ((src :lisp)) ((crf :crf))) @@ -982,5 +948,5 @@ -(define-ppc-vinsn unbox-u8 (((dest :u8)) +(define-ppc32-vinsn unbox-u8 (((dest :u8)) ((src :lisp)) ((crf0 (:crf 0)))) @@ -992,5 +958,5 @@ :got-it) -(define-ppc-vinsn unbox-s8 (((dest :s8)) +(define-ppc32-vinsn unbox-s8 (((dest :s8)) ((src :lisp)) ((crf :crf))) @@ -1007,5 +973,5 @@ :got-it) -(define-ppc-vinsn unbox-base-char (((dest :u32)) +(define-ppc32-vinsn unbox-base-char (((dest :u32)) ((src :lisp)) ((crf :crf))) @@ -1017,5 +983,5 @@ :got-it) -(define-ppc-vinsn unbox-character (((dest :u32)) +(define-ppc32-vinsn unbox-character (((dest :u32)) ((src :lisp)) ((crf :crf))) @@ -1027,5 +993,5 @@ :got-it) -(define-ppc-vinsn unbox-bit (((dest :u32)) +(define-ppc32-vinsn unbox-bit (((dest :u32)) ((src :lisp)) ((crf :crf))) @@ -1036,5 +1002,5 @@ :got-it) -(define-ppc-vinsn unbox-bit-bit0 (((dest :u32)) +(define-ppc32-vinsn unbox-bit-bit0 (((dest :u32)) ((src :lisp)) ((crf :crf))) @@ -1045,5 +1011,5 @@ :got-it) -(define-ppc-vinsn fixnum->fpr (((dest :double-float)) +(define-ppc32-vinsn fixnum->fpr (((dest :double-float)) ((src :lisp)) ((imm :s32))) @@ -1059,34 +1025,34 @@ -(define-ppc-vinsn shift-right-variable-word (((dest :u32)) +(define-ppc32-vinsn shift-right-variable-word (((dest :u32)) ((src :u32) (sh :u32))) (srw dest src sh)) -(define-ppc-vinsn u32logandc2 (((dest :u32)) +(define-ppc32-vinsn u32logandc2 (((dest :u32)) ((x :u32) (y :u32))) (andc dest x y)) -(define-ppc-vinsn u32logior (((dest :u32)) +(define-ppc32-vinsn u32logior (((dest :u32)) ((x :u32) (y :u32))) (or dest x y)) -(define-ppc-vinsn rotate-left-variable-word (((dest :u32)) +(define-ppc32-vinsn rotate-left-variable-word (((dest :u32)) ((src :u32) (rot :u32))) (rlwnm dest src rot 0 31)) -(define-ppc-vinsn complement-shift-count (((dest :u32)) +(define-ppc32-vinsn complement-shift-count (((dest :u32)) ((src :u32))) (subfic dest src 32)) -(define-ppc-vinsn extract-lowbyte (((dest :u32)) +(define-ppc32-vinsn extract-lowbyte (((dest :u32)) ((src :lisp))) (clrlwi dest src (- ppc32::nbits-in-word ppc32::num-subtag-bits))) ; Set DEST to the difference between the low byte of SRC and BYTEVAL. -(define-ppc-vinsn extract-compare-lowbyte (((dest :u32)) +(define-ppc32-vinsn extract-compare-lowbyte (((dest :u32)) ((src :lisp) (byteval :u8const))) @@ -1098,5 +1064,5 @@ ; a fixnum. Leave the object's tag in TAG. ; This is a little easier if CRF is CR0. -(define-ppc-vinsn eq-if-fixnum (((crf :crf) +(define-ppc32-vinsn eq-if-fixnum (((crf :crf) (tag :u8)) ((object :lisp)) @@ -1108,5 +1074,5 @@ (cmpwi crf tag ppc32::tag-fixnum))) -(define-ppc-vinsn trap-unless-tag= (() +(define-ppc32-vinsn trap-unless-tag= (() ((object :lisp) (tagval :u16const)) @@ -1115,5 +1081,5 @@ (twnei tag tagval)) -(define-ppc-vinsn trap-unless-fulltag= (() +(define-ppc32-vinsn trap-unless-fulltag= (() ((object :lisp) (tagval :u16const)) @@ -1122,5 +1088,5 @@ (twnei tag tagval)) -(define-ppc-vinsn trap-unless-lowbyte= (() +(define-ppc32-vinsn trap-unless-lowbyte= (() ((object :lisp) (tagval :u16const)) @@ -1129,5 +1095,5 @@ (twnei tag tagval)) -(define-ppc-vinsn trap-unless-typecode= (() +(define-ppc32-vinsn trap-unless-typecode= (() ((object :lisp) (tagval :u16const)) @@ -1141,10 +1107,10 @@ (twnei tag tagval)) -(define-ppc-vinsn subtract-constant (((dest :imm)) +(define-ppc32-vinsn subtract-constant (((dest :imm)) ((src :imm) (const :s16const))) (subi dest src const)) -(define-ppc-vinsn trap-unless-numeric-type (() +(define-ppc32-vinsn trap-unless-numeric-type (() ((object :lisp) (maxtype :u16const)) @@ -1177,5 +1143,5 @@ ;; 31.)) -(define-ppc-vinsn extract-variable-bit (((dest :u8)) +(define-ppc32-vinsn extract-variable-bit (((dest :u8)) ((src :u32) (bitnum :u8)) @@ -1185,5 +1151,5 @@ -(define-ppc-vinsn extract-variable-bit[fixnum] (((dest :imm)) +(define-ppc32-vinsn extract-variable-bit-fixnum (((dest :imm)) ((src :u32) (bitnum :u8)) @@ -1203,5 +1169,5 @@ ;; between T and NIL) or 0. -(define-ppc-vinsn bit31->truth (((dest :lisp) +(define-ppc32-vinsn bit31->truth (((dest :lisp) (bits :u32)) ((bits :u32)) @@ -1210,5 +1176,5 @@ (addi dest bits ppc32::nil-value)) -(define-ppc-vinsn invert-bit31 (((bits :u32)) +(define-ppc32-vinsn invert-bit31 (((bits :u32)) ((bits :u32)) ()) @@ -1230,10 +1196,10 @@ -(define-ppc-vinsn eq0->bit31 (((bits :u32)) +(define-ppc32-vinsn eq0->bit31 (((bits :u32)) ((src (t (:ne bits))))) (cntlzw bits src) (srwi bits bits 5)) ; bits = 0000...000X -(define-ppc-vinsn ne0->bit31 (((bits :u32)) +(define-ppc32-vinsn ne0->bit31 (((bits :u32)) ((src (t (:ne bits))))) (cntlzw bits src) @@ -1241,10 +1207,10 @@ (srwi bits bits 31)) ; bits = 0000...000X -(define-ppc-vinsn lt0->bit31 (((bits :u32)) +(define-ppc32-vinsn lt0->bit31 (((bits :u32)) ((src (t (:ne bits))))) (srwi bits src 31)) ; bits = 0000...000X -(define-ppc-vinsn ge0->bit31 (((bits :u32)) +(define-ppc32-vinsn ge0->bit31 (((bits :u32)) ((src (t (:ne bits))))) (srwi bits src 31) @@ -1252,5 +1218,5 @@ -(define-ppc-vinsn le0->bit31 (((bits :u32)) +(define-ppc32-vinsn le0->bit31 (((bits :u32)) ((src (t (:ne bits))))) (neg bits src) @@ -1258,5 +1224,5 @@ (srwi bits bits 31)) ; bits = 0000...000X -(define-ppc-vinsn gt0->bit31 (((bits :u32)) +(define-ppc32-vinsn gt0->bit31 (((bits :u32)) ((src (t (:ne bits))))) (subi bits src 1) @@ -1264,5 +1230,5 @@ (srwi bits bits 31)) ; bits = 0000...000X -(define-ppc-vinsn ne->bit31 (((bits :u32)) +(define-ppc32-vinsn ne->bit31 (((bits :u32)) ((x t) (y t)) @@ -1273,5 +1239,5 @@ (srwi bits bits 31)) ; bits = 0000...000X -(define-ppc-vinsn fulltag->bit31 (((bits :u32)) +(define-ppc32-vinsn fulltag->bit31 (((bits :u32)) ((lispobj :lisp) (tagval :u8const)) @@ -1283,5 +1249,5 @@ -(define-ppc-vinsn eq->bit31 (((bits :u32)) +(define-ppc32-vinsn eq->bit31 (((bits :u32)) ((x t) (y t))) @@ -1290,5 +1256,5 @@ (srwi bits bits 5)) ; bits = 0000...000X -(define-ppc-vinsn eqnil->bit31 (((bits :u32)) +(define-ppc32-vinsn eqnil->bit31 (((bits :u32)) ((x t))) (subi bits x ppc32::nil-value) @@ -1296,5 +1262,5 @@ (srwi bits bits 5)) -(define-ppc-vinsn ne->bit31 (((bits :u32)) +(define-ppc32-vinsn ne->bit31 (((bits :u32)) ((x t) (y t))) @@ -1304,5 +1270,5 @@ (xori bits bits 1)) -(define-ppc-vinsn nenil->bit31 (((bits :u32)) +(define-ppc32-vinsn nenil->bit31 (((bits :u32)) ((x t))) (subi bits x ppc32::nil-value) @@ -1311,5 +1277,5 @@ (xori bits bits 1)) -(define-ppc-vinsn lt->bit31 (((bits :u32)) +(define-ppc32-vinsn lt->bit31 (((bits :u32)) ((x (t (:ne bits))) (y (t (:ne bits))))) @@ -1321,5 +1287,5 @@ (srwi bits bits 31)) ; bits = 0000...000X -(define-ppc-vinsn ltu->bit31 (((bits :u32)) +(define-ppc32-vinsn ltu->bit31 (((bits :u32)) ((x :u32) (y :u32))) @@ -1328,5 +1294,5 @@ (neg bits bits)) -(define-ppc-vinsn le->bit31 (((bits :u32)) +(define-ppc32-vinsn le->bit31 (((bits :u32)) ((x (t (:ne bits))) (y (t (:ne bits))))) @@ -1338,5 +1304,5 @@ (srwi bits bits 31)) ; bits = 0000...000X -(define-ppc-vinsn leu->bit31 (((bits :u32)) +(define-ppc32-vinsn leu->bit31 (((bits :u32)) ((x :u32) (y :u32))) @@ -1344,5 +1310,5 @@ (addze bits ppc::rzero)) -(define-ppc-vinsn gt->bit31 (((bits :u32)) +(define-ppc32-vinsn gt->bit31 (((bits :u32)) ((x (t (:ne bits))) (y (t (:ne bits))))) @@ -1354,5 +1320,5 @@ (srwi bits bits 31)) ; bits = 0000...000X -(define-ppc-vinsn gtu->bit31 (((bits :u32)) +(define-ppc32-vinsn gtu->bit31 (((bits :u32)) ((x :u32) (y :u32))) @@ -1361,5 +1327,5 @@ (neg bits bits)) -(define-ppc-vinsn ge->bit31 (((bits :u32)) +(define-ppc32-vinsn ge->bit31 (((bits :u32)) ((x (t (:ne bits))) (y (t (:ne bits))))) @@ -1370,5 +1336,5 @@ (srwi bits bits 31)) ; bits = 0000...000X -(define-ppc-vinsn geu->bit31 (((bits :u32)) +(define-ppc32-vinsn geu->bit31 (((bits :u32)) ((x :u32) (y :u32))) @@ -1383,5 +1349,5 @@ ; MFCR takes three cycles and waits for previous instructions to complete. ; Of course, using a CR field costs us something as well. -(define-ppc-vinsn crbit->bit31 (((bits :u32)) +(define-ppc32-vinsn crbit->bit31 (((bits :u32)) ((crf :crf) (bitnum :crbit)) @@ -1391,5 +1357,5 @@ -(define-ppc-vinsn compare (((crf :crf)) +(define-ppc32-vinsn compare (((crf :crf)) ((arg0 t) (arg1 t)) @@ -1397,9 +1363,9 @@ (cmpw crf arg0 arg1)) -(define-ppc-vinsn compare-to-nil (((crf :crf)) +(define-ppc32-vinsn compare-to-nil (((crf :crf)) ((arg0 t))) (cmpwi crf arg0 ppc32::nil-value)) -(define-ppc-vinsn compare-logical (((crf :crf)) +(define-ppc32-vinsn compare-logical (((crf :crf)) ((arg0 t) (arg1 t)) @@ -1407,5 +1373,5 @@ (cmplw crf arg0 arg1)) -(define-ppc-vinsn double-float-compare (((crf :crf)) +(define-ppc32-vinsn double-float-compare (((crf :crf)) ((arg0 :double-float) (arg1 :double-float)) @@ -1414,5 +1380,5 @@ -(define-ppc-vinsn double-float+-2 (((result :double-float)) +(define-ppc32-vinsn double-float+-2 (((result :double-float)) ((x :double-float) (y :double-float)) @@ -1420,5 +1386,5 @@ (fadd result x y)) -(define-ppc-vinsn double-float--2 (((result :double-float)) +(define-ppc32-vinsn double-float--2 (((result :double-float)) ((x :double-float) (y :double-float)) @@ -1426,5 +1392,5 @@ (fsub result x y)) -(define-ppc-vinsn double-float*-2 (((result :double-float)) +(define-ppc32-vinsn double-float*-2 (((result :double-float)) ((x :double-float) (y :double-float)) @@ -1432,5 +1398,5 @@ (fmul result x y)) -(define-ppc-vinsn double-float/-2 (((result :double-float)) +(define-ppc32-vinsn double-float/-2 (((result :double-float)) ((x :double-float) (y :double-float)) @@ -1438,5 +1404,5 @@ (fdiv result x y)) -(define-ppc-vinsn single-float+-2 (((result :single-float)) +(define-ppc32-vinsn single-float+-2 (((result :single-float)) ((x :single-float) (y :single-float)) @@ -1444,5 +1410,5 @@ (fadds result x y)) -(define-ppc-vinsn single-float--2 (((result :single-float)) +(define-ppc32-vinsn single-float--2 (((result :single-float)) ((x :single-float) (y :single-float)) @@ -1450,5 +1416,5 @@ (fsubs result x y)) -(define-ppc-vinsn single-float*-2 (((result :single-float)) +(define-ppc32-vinsn single-float*-2 (((result :single-float)) ((x :single-float) (y :single-float)) @@ -1456,5 +1422,5 @@ (fmuls result x y)) -(define-ppc-vinsn single-float/-2 (((result :single-float)) +(define-ppc32-vinsn single-float/-2 (((result :single-float)) ((x :single-float) (y :single-float)) @@ -1466,5 +1432,5 @@ -(define-ppc-vinsn compare-unsigned (((crf :crf)) +(define-ppc32-vinsn compare-unsigned (((crf :crf)) ((arg0 :imm) (arg1 :imm)) @@ -1472,5 +1438,5 @@ (cmplw crf arg0 arg1)) -(define-ppc-vinsn compare-signed-s16const (((crf :crf)) +(define-ppc32-vinsn compare-signed-s16const (((crf :crf)) ((arg0 :imm) (imm :s16const)) @@ -1478,5 +1444,5 @@ (cmpwi crf arg0 imm)) -(define-ppc-vinsn compare-unsigned-u16const (((crf :crf)) +(define-ppc32-vinsn compare-unsigned-u16const (((crf :crf)) ((arg0 :u32) (imm :u16const)) @@ -1488,5 +1454,5 @@ ;; Extract a constant bit (0-31) from src; make it be bit 31 of dest. ;; Bitnum is treated mod 32. -(define-ppc-vinsn extract-constant-ppc-bit (((dest :u32)) +(define-ppc32-vinsn extract-constant-ppc-bit (((dest :u32)) ((src :imm) (bitnum :u16const)) @@ -1495,5 +1461,5 @@ -(define-ppc-vinsn set-constant-ppc-bit-to-variable-value (((dest :u32)) +(define-ppc32-vinsn set-constant-ppc-bit-to-variable-value (((dest :u32)) ((src :u32) (bitval :u32) ; 0 or 1 @@ -1501,5 +1467,5 @@ (rlwimi dest bitval (:apply - 31 bitnum) bitnum bitnum)) -(define-ppc-vinsn set-constant-ppc-bit-to-1 (((dest :u32)) +(define-ppc32-vinsn set-constant-ppc-bit-to-1 (((dest :u32)) ((src :u32) (bitnum :u8const))) @@ -1509,5 +1475,5 @@ (ori dest src (:apply ash #x8000 (:apply - (:apply - bitnum 16)))))) -(define-ppc-vinsn set-constant-ppc-bit-to-0 (((dest :u32)) +(define-ppc32-vinsn set-constant-ppc-bit-to-0 (((dest :u32)) ((src :u32) (bitnum :u8const))) @@ -1515,5 +1481,5 @@ -(define-ppc-vinsn insert-bit-0 (((dest :u32)) +(define-ppc32-vinsn insert-bit-0 (((dest :u32)) ((src :u32) (val :u32))) @@ -1527,5 +1493,5 @@ ; I think ... ; Actually, it'd be "unbox, then subtract from 30". -(define-ppc-vinsn extract-variable-non-insane-bit (((dest :u32)) +(define-ppc32-vinsn extract-variable-non-insane-bit (((dest :u32)) ((src :imm) (bit :imm)) @@ -1537,32 +1503,32 @@ ; Operations on lists and cons cells -(define-ppc-vinsn %cdr (((dest :lisp)) +(define-ppc32-vinsn %cdr (((dest :lisp)) ((src :lisp))) (lwz dest ppc32::cons.cdr src)) -(define-ppc-vinsn %car (((dest :lisp)) +(define-ppc32-vinsn %car (((dest :lisp)) ((src :lisp))) (lwz dest ppc32::cons.car src)) -(define-ppc-vinsn %set-car (() +(define-ppc32-vinsn %set-car (() ((cell :lisp) (new :lisp))) (stw new ppc32::cons.car cell)) -(define-ppc-vinsn %set-cdr (() +(define-ppc32-vinsn %set-cdr (() ((cell :lisp) (new :lisp))) (stw new ppc32::cons.cdr cell)) -(define-ppc-vinsn load-adl (() +(define-ppc32-vinsn load-adl (() ((n :u32const))) (lis ppc::nargs (:apply ldb (byte 16 16) n)) (ori ppc::nargs ppc::nargs (:apply ldb (byte 16 0) n))) -(define-ppc-vinsn set-nargs (() +(define-ppc32-vinsn set-nargs (() ((n :s16const))) (li ppc::nargs (:apply ash n ppc32::word-shift))) -(define-ppc-vinsn scale-nargs (() +(define-ppc32-vinsn scale-nargs (() ((nfixed :s16const))) ((:pred > nfixed 0) @@ -1571,15 +1537,15 @@ -(define-ppc-vinsn (vpush-register :push :node :vsp) +(define-ppc32-vinsn (vpush-register :push :node :vsp) (() ((reg :lisp))) (stwu reg -4 ppc::vsp)) -(define-ppc-vinsn (vpush-register-arg :push :node :vsp :outgoing-argument) +(define-ppc32-vinsn (vpush-register-arg :push :node :vsp :outgoing-argument) (() ((reg :lisp))) (stwu reg -4 ppc::vsp)) -(define-ppc-vinsn (vpop-register :pop :node :vsp) +(define-ppc32-vinsn (vpop-register :pop :node :vsp) (((dest :lisp)) ()) @@ -1588,5 +1554,5 @@ -(define-ppc-vinsn copy-node-gpr (((dest :lisp)) +(define-ppc32-vinsn copy-node-gpr (((dest :lisp)) ((src :lisp))) ((:not (:pred = @@ -1595,5 +1561,5 @@ (mr dest src))) -(define-ppc-vinsn copy-gpr (((dest t)) +(define-ppc32-vinsn copy-gpr (((dest t)) ((src t))) ((:not (:pred = @@ -1603,5 +1569,5 @@ -(define-ppc-vinsn copy-fpr (((dest t)) +(define-ppc32-vinsn copy-fpr (((dest t)) ((src t))) ((:not (:pred = @@ -1610,9 +1576,9 @@ (fmr dest src))) -(define-ppc-vinsn vcell-ref (((dest :lisp)) +(define-ppc32-vinsn vcell-ref (((dest :lisp)) ((vcell :lisp))) (lwz dest ppc32::misc-data-offset vcell)) -(define-ppc-vinsn vcell-set (() +(define-ppc32-vinsn vcell-set (() ((vcell :lisp) (value :lisp))) @@ -1620,5 +1586,5 @@ -(define-ppc-vinsn make-vcell (((dest :lisp)) +(define-ppc32-vinsn make-vcell (((dest :lisp)) ((closed (:lisp :ne dest))) ((header :u32))) @@ -1631,5 +1597,5 @@ (stw closed ppc32::value-cell.value dest)) -(define-ppc-vinsn make-tsp-vcell (((dest :lisp)) +(define-ppc32-vinsn make-tsp-vcell (((dest :lisp)) ((closed :lisp)) ((header :u32))) @@ -1643,5 +1609,5 @@ (la dest (+ 8 ppc32::fulltag-misc) ppc::tsp)) -(define-ppc-vinsn make-tsp-cons (((dest :lisp)) +(define-ppc32-vinsn make-tsp-cons (((dest :lisp)) ((car :lisp) (cdr :lisp)) ()) @@ -1655,14 +1621,14 @@ -(define-ppc-vinsn %closure-code% (((dest :lisp)) +(define-ppc32-vinsn %closure-code% (((dest :lisp)) ()) (lwz dest (+ ppc32::symbol.vcell (ppc32::nrs-offset %closure-code%) ppc32::nil-value) 0)) -(define-ppc-vinsn (call-subprim :call :subprim-call) (() +(define-ppc32-vinsn (call-subprim :call :subprim-call) (() ((spno :s32const))) (bla spno)) -(define-ppc-vinsn (jump-subprim :jumpLR) (() +(define-ppc32-vinsn (jump-subprim :jumpLR) (() ((spno :s32const))) (ba spno)) @@ -1670,14 +1636,14 @@ ; Same as "call-subprim", but gives us a place to ; track args, results, etc. -(define-ppc-vinsn (call-subprim-0 :call :subprim-call) (((dest t)) +(define-ppc32-vinsn (call-subprim-0 :call :subprim-call) (((dest t)) ((spno :s32const))) (bla spno)) -(define-ppc-vinsn (call-subprim-1 :call :subprim-call) (((dest t)) +(define-ppc32-vinsn (call-subprim-1 :call :subprim-call) (((dest t)) ((spno :s32const) (z t))) (bla spno)) -(define-ppc-vinsn (call-subprim-2 :call :subprim-call) (((dest t)) +(define-ppc32-vinsn (call-subprim-2 :call :subprim-call) (((dest t)) ((spno :s32const) (y t) @@ -1685,5 +1651,5 @@ (bla spno)) -(define-ppc-vinsn (call-subprim-3 :call :subprim-call) (((dest t)) +(define-ppc32-vinsn (call-subprim-3 :call :subprim-call) (((dest t)) ((spno :s32const) (x t) @@ -1692,5 +1658,5 @@ (bla spno)) -(define-ppc-vinsn event-poll (() +(define-ppc32-vinsn event-poll (() ()) (lwz ppc::nargs ppc32::tcr.interrupt-level ppc::rcontext) @@ -1699,10 +1665,10 @@ ; Unconditional (pc-relative) branch -(define-ppc-vinsn (jump :jump) +(define-ppc32-vinsn (jump :jump) (() ((label :label))) (b label)) -(define-ppc-vinsn (call-label :call) (() +(define-ppc32-vinsn (call-label :call) (() ((label :label))) (bl label)) @@ -1710,10 +1676,10 @@ ; just like JUMP, only (implicitly) asserts that the following ; code is somehow reachable. -(define-ppc-vinsn (non-barrier-jump :xref) (() +(define-ppc32-vinsn (non-barrier-jump :xref) (() ((label :label))) (b label)) -(define-ppc-vinsn (cbranch-true :branch) (() +(define-ppc32-vinsn (cbranch-true :branch) (() ((label :label) (crf :crf) @@ -1721,5 +1687,5 @@ (bt (:apply + crf crbit) label)) -(define-ppc-vinsn (cbranch-false :branch) (() +(define-ppc32-vinsn (cbranch-false :branch) (() ((label :label) (crf :crf) @@ -1727,5 +1693,5 @@ (bf (:apply + crf crbit) label)) -(define-ppc-vinsn check-trap-error (() +(define-ppc32-vinsn check-trap-error (() ()) (beq+ 0 :no-error) @@ -1734,10 +1700,10 @@ -(define-ppc-vinsn lisp-word-ref (((dest t)) +(define-ppc32-vinsn lisp-word-ref (((dest t)) ((base t) (offset t))) (lwzx dest base offset)) -(define-ppc-vinsn lisp-word-ref-c (((dest t)) +(define-ppc32-vinsn lisp-word-ref-c (((dest t)) ((base t) (offset :s16const))) @@ -1747,5 +1713,5 @@ ;; Load an unsigned, 32-bit constant into a destination register. -(define-ppc-vinsn (lwi :constant-ref) (((dest :imm)) +(define-ppc32-vinsn (lwi :constant-ref) (((dest :imm)) ((intval :u32const)) ()) @@ -1764,5 +1730,5 @@ ; Exactly the same thing, but take a signed integer value -(define-ppc-vinsn lwi-s32 (((dest :imm)) +(define-ppc32-vinsn lwi-s32 (((dest :imm)) ((intval :s32const)) ()) @@ -1780,5 +1746,5 @@ (ori dest dest (:apply logand intval #xffff)))))) -(define-ppc-vinsn discard-temp-frame (() +(define-ppc32-vinsn discard-temp-frame (() ()) (lwz ppc::tsp 0 ppc::tsp)) @@ -1792,5 +1758,5 @@ ;;; The caller always has to reserve a 24-byte linkage area ;;; (large chunks of which are unused). -(define-ppc-vinsn alloc-c-frame (() +(define-ppc32-vinsn alloc-c-frame (() ((n-c-args :u16const))) ;; Always reserve space for at least 8 args and space for a lisp @@ -1820,5 +1786,5 @@ (stw ppc::rzero ppc32::c-frame.savelr ppc::sp)) -(define-ppc-vinsn alloc-eabi-c-frame (() +(define-ppc32-vinsn alloc-eabi-c-frame (() ((n-c-args :u16const))) ; Always reserve space for at least 8 args and space for a lisp @@ -1845,5 +1811,5 @@ ; to do the memory reference than it would be to keep track of the size ; of each frame. -(define-ppc-vinsn discard-c-frame (() +(define-ppc32-vinsn discard-c-frame (() ()) (lwz ppc::sp 0 ppc::sp)) @@ -1852,59 +1818,59 @@ -(define-ppc-vinsn set-c-arg (() +(define-ppc32-vinsn set-c-arg (() ((argval :u32) (argnum :u16const))) (stw argval (:apply + ppc32::c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn set-single-c-arg (() +(define-ppc32-vinsn set-single-c-arg (() ((argval :single-float) (argnum :u16const))) (stfs argval (:apply + ppc32::c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn set-double-c-arg (() +(define-ppc32-vinsn set-double-c-arg (() ((argval :double-float) (argnum :u16const))) (stfd argval (:apply + ppc32::c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn reload-single-c-arg (((argval :single-float)) +(define-ppc32-vinsn reload-single-c-arg (((argval :single-float)) ((argnum :u16const))) (lfs argval (:apply + ppc32::c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn reload-double-c-arg (((argval :double-float)) +(define-ppc32-vinsn reload-double-c-arg (((argval :double-float)) ((argnum :u16const))) (lfd argval (:apply + ppc32::c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn set-eabi-c-arg (() +(define-ppc32-vinsn set-eabi-c-arg (() ((argval :u32) (argnum :u16const))) (stw argval (:apply + ppc32::eabi-c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn set-single-eabi-c-arg (() +(define-ppc32-vinsn set-single-eabi-c-arg (() ((argval :single-float) (argnum :u16const))) (stfs argval (:apply + ppc32::eabi-c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn set-double-eabi-c-arg (() +(define-ppc32-vinsn set-double-eabi-c-arg (() ((argval :double-float) (argnum :u16const))) (stfd argval (:apply + ppc32::eabi-c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn reload-single-eabi-c-arg (((argval :single-float)) +(define-ppc32-vinsn reload-single-eabi-c-arg (((argval :single-float)) ((argnum :u16const))) (lfs argval (:apply + ppc32::eabi-c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn reload-double-eabi-c-arg (((argval :double-float)) +(define-ppc32-vinsn reload-double-eabi-c-arg (((argval :double-float)) ((argnum :u16const))) (lfd argval (:apply + ppc32::eabi-c-frame.param0 (:apply ash argnum ppc32::word-shift)) ppc::sp)) -(define-ppc-vinsn (load-nil :constant-ref) (((dest t)) +(define-ppc32-vinsn (load-nil :constant-ref) (((dest t)) ()) (li dest ppc32::nil-value)) -(define-ppc-vinsn (load-t :constant-ref) (((dest t)) +(define-ppc32-vinsn (load-t :constant-ref) (((dest t)) ()) (li dest (+ ppc32::t-offset ppc32::nil-value))) -(define-ppc-vinsn set-eq-bit (((dest :crf)) +(define-ppc32-vinsn set-eq-bit (((dest :crf)) ()) (creqv (:apply + ppc::ppc-eq-bit dest) @@ -1912,14 +1878,14 @@ (:apply + ppc::ppc-eq-bit dest))) -(define-ppc-vinsn (ref-constant :constant-ref) (((dest :lisp)) +(define-ppc32-vinsn (ref-constant :constant-ref) (((dest :lisp)) ((src :s16const))) (lwz dest (:apply + ppc32::misc-data-offset (:apply ash (:apply 1+ src) 2)) ppc::fn)) -(define-ppc-vinsn ref-indexed-constant (((dest :lisp)) +(define-ppc32-vinsn ref-indexed-constant (((dest :lisp)) ((idxreg :s32))) (lwzx dest ppc::fn idxreg)) -(define-ppc-vinsn cons (((dest :lisp)) +(define-ppc32-vinsn cons (((dest :lisp)) ((newcar :lisp) (newcdr :lisp))) @@ -1934,5 +1900,5 @@ ;; subtag had better be a PPC-NODE-SUBTAG of some sort! -(define-ppc-vinsn %ppc-gvector (((dest :lisp)) +(define-ppc32-vinsn %ppc-gvector (((dest :lisp)) ((Rheader :u32) (nbytes :u32const)) @@ -1959,5 +1925,5 @@ ;; allocate a small (phys size <= 32K bytes) misc obj of known size/subtag -(define-ppc-vinsn %alloc-misc-fixed (((dest :lisp)) +(define-ppc32-vinsn %alloc-misc-fixed (((dest :lisp)) ((Rheader :u32) (nbytes :u32const))) @@ -1971,5 +1937,5 @@ (clrrwi ppc::allocptr ppc::allocptr ppc32::ntagbits)) -(define-ppc-vinsn vstack-discard (() +(define-ppc32-vinsn vstack-discard (() ((nwords :u32const))) ((:not (:pred = nwords 0)) @@ -1977,5 +1943,5 @@ -(define-ppc-vinsn lcell-load (((dest :lisp)) +(define-ppc32-vinsn lcell-load (((dest :lisp)) ((cell :lcell) (top :lcell))) @@ -1984,10 +1950,10 @@ (:apply calc-lcell-offset cell)) ppc::vsp)) -(define-ppc-vinsn vframe-load (((dest :lisp)) +(define-ppc32-vinsn vframe-load (((dest :lisp)) ((frame-offset :u16const) (cur-vsp :u16const))) (lwz dest (:apply - (:apply - cur-vsp 4) frame-offset) ppc::vsp)) -(define-ppc-vinsn lcell-store (() +(define-ppc32-vinsn lcell-store (() ((src :lisp) (cell :lcell) @@ -1997,5 +1963,5 @@ (:apply calc-lcell-offset cell)) ppc::vsp)) -(define-ppc-vinsn vframe-store (() +(define-ppc32-vinsn vframe-store (() ((src :lisp) (frame-offset :u16const) @@ -2003,9 +1969,9 @@ (stw src (:apply - (:apply - cur-vsp 4) frame-offset) ppc::vsp)) -(define-ppc-vinsn load-vframe-address (((dest :imm)) +(define-ppc32-vinsn load-vframe-address (((dest :imm)) ((offset :s16const))) (la dest offset ppc::vsp)) -(define-ppc-vinsn copy-lexpr-argument (() +(define-ppc32-vinsn copy-lexpr-argument (() () ((temp :lisp))) @@ -2016,5 +1982,5 @@ ; Treat the low 8 bits of VAL as an unsigned integer; set RESULT to the equivalent fixnum. -(define-ppc-vinsn u8->fixnum (((result :imm)) +(define-ppc32-vinsn u8->fixnum (((result :imm)) ((val :u8)) ()) @@ -2022,5 +1988,5 @@ ; Treat the low 8 bits of VAL as a signed integer; set RESULT to the equivalent fixnum. -(define-ppc-vinsn s8->fixnum (((result :imm)) +(define-ppc32-vinsn s8->fixnum (((result :imm)) ((val :s8)) ()) @@ -2030,5 +1996,5 @@ ; Treat the low 16 bits of VAL as an unsigned integer; set RESULT to the equivalent fixnum. -(define-ppc-vinsn u16->fixnum (((result :imm)) +(define-ppc32-vinsn u16->fixnum (((result :imm)) ((val :u16)) ()) @@ -2036,5 +2002,5 @@ ; Treat the low 16 bits of VAL as a signed integer; set RESULT to the equivalent fixnum. -(define-ppc-vinsn s16->fixnum (((result :imm)) +(define-ppc32-vinsn s16->fixnum (((result :imm)) ((val :s16)) ()) @@ -2042,5 +2008,5 @@ (srawi result result (- (- ppc32::nbits-in-word 16) ppc32::fixnumshift))) -(define-ppc-vinsn fixnum->s16 (((result :s16)) +(define-ppc32-vinsn fixnum->s16 (((result :s16)) ((src :imm))) (srawi result src ppc32::fixnumshift)) @@ -2049,5 +2015,5 @@ ; There should be something very much like this that takes a stack-consed ; bignum result ... -(define-ppc-vinsn s32->integer (((result :lisp)) +(define-ppc32-vinsn s32->integer (((result :lisp)) ((src :s32)) ((crf (:crf 0)) ; a casualty @@ -2068,5 +2034,5 @@ ; An unsigned 32-bit untagged value can be either a 1 or a 2-digit bignum. -(define-ppc-vinsn u32->integer (((result :lisp)) +(define-ppc32-vinsn u32->integer (((result :lisp)) ((src :u32)) ((crf (:crf 0)) ; a casualty @@ -2091,18 +2057,18 @@ :done) -(define-ppc-vinsn u16->u32 (((dest :u32)) +(define-ppc32-vinsn u16->u32 (((dest :u32)) ((src :u16))) (clrlwi dest src 16)) -(define-ppc-vinsn u8->u32 (((dest :u32)) +(define-ppc32-vinsn u8->u32 (((dest :u32)) ((src :u8))) (clrlwi dest src 24)) -(define-ppc-vinsn s16->s32 (((dest :s32)) +(define-ppc32-vinsn s16->s32 (((dest :s32)) ((src :s16))) (extsh dest src)) -(define-ppc-vinsn s8->s32 (((dest :s32)) +(define-ppc32-vinsn s8->s32 (((dest :s32)) ((src :s8))) (extsb dest src)) @@ -2113,5 +2079,5 @@ ; Heap-cons a double-float to store contents of FPREG. Hope that we don't do ; this blindly. -(define-ppc-vinsn double->heap (((result :lisp)) ; tagged as a double-float +(define-ppc32-vinsn double->heap (((result :lisp)) ; tagged as a double-float ((fpreg :double-float)) ((header-temp :u32))) @@ -2128,5 +2094,5 @@ ; 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-ppc-vinsn single->heap (((result :lisp)) ; tagged as a single-float +(define-ppc32-vinsn single->heap (((result :lisp)) ; tagged as a single-float ((fpreg :single-float)) ((header-temp :u32))) @@ -2141,5 +2107,5 @@ ; "dest" is preallocated, presumably on a stack somewhere. -(define-ppc-vinsn store-double (() +(define-ppc32-vinsn store-double (() ((dest :lisp) (source :double-float)) @@ -2147,5 +2113,5 @@ (stfd source ppc32::double-float.value dest)) -(define-ppc-vinsn get-double (((target :double-float)) +(define-ppc32-vinsn get-double (((target :double-float)) ((source :lisp)) ()) @@ -2156,5 +2122,5 @@ ;;; instead of replicating it .. -(define-ppc-vinsn get-double? (((target :double-float)) +(define-ppc32-vinsn get-double? (((target :double-float)) ((source :lisp)) ((tag :u8) @@ -2169,5 +2135,5 @@ -(define-ppc-vinsn store-single (() +(define-ppc32-vinsn store-single (() ((dest :lisp) (source :single-float)) @@ -2175,5 +2141,5 @@ (stfs source ppc32::single-float.value dest)) -(define-ppc-vinsn get-single (((target :single-float)) +(define-ppc32-vinsn get-single (((target :single-float)) ((source :lisp)) ()) @@ -2181,10 +2147,10 @@ ; ... of characters ... -(define-ppc-vinsn charcode->u16 (((dest :u16)) +(define-ppc32-vinsn charcode->u16 (((dest :u16)) ((src :imm)) ()) (srwi dest src ppc32::charcode-shift)) -(define-ppc-vinsn character->fixnum (((dest :lisp)) +(define-ppc32-vinsn character->fixnum (((dest :lisp)) ((src :lisp)) ()) @@ -2195,9 +2161,9 @@ (- ppc32::least-significant-bit ppc32::fixnumshift))) -(define-ppc-vinsn character->code (((dest :u32)) +(define-ppc32-vinsn character->code (((dest :u32)) ((src :lisp))) (rlwinm dest src ppc32::charcode-shift ppc32::charcode-shift ppc32::least-significant-bit)) -(define-ppc-vinsn charcode->fixnum (((dest :lisp)) +(define-ppc32-vinsn charcode->fixnum (((dest :lisp)) ((src :imm)) ()) @@ -2208,5 +2174,5 @@ (- ppc32::least-significant-bit ppc32::fixnumshift))) -(define-ppc-vinsn fixnum->char (((dest :lisp)) +(define-ppc32-vinsn fixnum->char (((dest :lisp)) ((src :imm)) ()) @@ -2214,5 +2180,5 @@ (addi dest dest ppc32::subtag-character)) -(define-ppc-vinsn u8->char (((dest :lisp)) +(define-ppc32-vinsn u8->char (((dest :lisp)) ((src :u8)) ()) @@ -2222,10 +2188,10 @@ ;; ... Macptrs ... -(define-ppc-vinsn deref-macptr (((addr :address)) +(define-ppc32-vinsn deref-macptr (((addr :address)) ((src :lisp)) ()) (lwz addr ppc32::macptr.address src)) -(define-ppc-vinsn set-macptr-address (() +(define-ppc32-vinsn set-macptr-address (() ((addr :address) (src :lisp)) @@ -2234,5 +2200,5 @@ -(define-ppc-vinsn macptr->heap (((dest :lisp)) +(define-ppc32-vinsn macptr->heap (((dest :lisp)) ((address :address)) ((header :u32))) @@ -2247,5 +2213,5 @@ (stw address ppc32::macptr.address dest)) -(define-ppc-vinsn macptr->stack (((dest :lisp)) +(define-ppc32-vinsn macptr->stack (((dest :lisp)) ((address :address)) ((header :u32))) @@ -2261,10 +2227,10 @@ -(define-ppc-vinsn adjust-stack-register (() +(define-ppc32-vinsn adjust-stack-register (() ((reg t) (amount :s16const))) (la reg amount reg)) -(define-ppc-vinsn adjust-vsp (() +(define-ppc32-vinsn adjust-vsp (() ((amount :s16const))) (la ppc::vsp amount ppc::vsp)) @@ -2272,10 +2238,10 @@ ;; Arithmetic on fixnums & unboxed numbers -(define-ppc-vinsn u32-lognot (((dest :u32)) +(define-ppc32-vinsn u32-lognot (((dest :u32)) ((src :u32)) ()) (not dest src)) -(define-ppc-vinsn fixnum-lognot (((dest :imm)) +(define-ppc32-vinsn fixnum-lognot (((dest :imm)) ((src :imm)) ((temp :u32))) @@ -2284,5 +2250,5 @@ -(define-ppc-vinsn negate-fixnum-overflow-inline (((dest :lisp)) +(define-ppc32-vinsn negate-fixnum-overflow-inline (((dest :lisp)) ((src :imm)) ((unboxed :s32) @@ -2302,5 +2268,5 @@ :done) -(define-ppc-vinsn negate-fixnum-overflow-ool (() +(define-ppc32-vinsn negate-fixnum-overflow-ool (() ((src :imm)) ) @@ -2311,5 +2277,5 @@ -(define-ppc-vinsn negate-fixnum-no-ovf (((dest :lisp)) +(define-ppc32-vinsn negate-fixnum-no-ovf (((dest :lisp)) ((src :imm))) @@ -2317,10 +2283,10 @@ -(define-ppc-vinsn logior-high (((dest :imm)) +(define-ppc32-vinsn logior-high (((dest :imm)) ((src :imm) (high :u16const))) (oris dest src high)) -(define-ppc-vinsn logior-low (((dest :imm)) +(define-ppc32-vinsn logior-low (((dest :imm)) ((src :imm) (low :u16const))) @@ -2329,5 +2295,5 @@ -(define-ppc-vinsn %logior2 (((dest :imm)) +(define-ppc32-vinsn %logior2 (((dest :imm)) ((x :imm) (y :imm)) @@ -2335,5 +2301,5 @@ (or dest x y)) -(define-ppc-vinsn logand-high (((dest :imm)) +(define-ppc32-vinsn logand-high (((dest :imm)) ((src :imm) (high :u16const)) @@ -2341,5 +2307,5 @@ (andis. dest src high)) -(define-ppc-vinsn logand-low (((dest :imm)) +(define-ppc32-vinsn logand-low (((dest :imm)) ((src :imm) (low :u16const)) @@ -2348,5 +2314,5 @@ -(define-ppc-vinsn %logand2 (((dest :imm)) +(define-ppc32-vinsn %logand2 (((dest :imm)) ((x :imm) (y :imm)) @@ -2354,10 +2320,10 @@ (and dest x y)) -(define-ppc-vinsn logxor-high (((dest :imm)) +(define-ppc32-vinsn logxor-high (((dest :imm)) ((src :imm) (high :u16const))) (xoris dest src high)) -(define-ppc-vinsn logxor-low (((dest :imm)) +(define-ppc32-vinsn logxor-low (((dest :imm)) ((src :imm) (low :u16const))) @@ -2366,5 +2332,5 @@ -(define-ppc-vinsn %logxor2 (((dest :imm)) +(define-ppc32-vinsn %logxor2 (((dest :imm)) ((x :imm) (y :imm)) @@ -2372,5 +2338,5 @@ (xor dest x y)) -(define-ppc-vinsn %ilsl (((dest :imm)) +(define-ppc32-vinsn %ilsl (((dest :imm)) ((count :imm) (src :imm)) @@ -2384,5 +2350,5 @@ :foo) -(define-ppc-vinsn %ilsl-c (((dest :imm)) +(define-ppc32-vinsn %ilsl-c (((dest :imm)) ((count :u8const) (src :imm))) @@ -2391,5 +2357,5 @@ -(define-ppc-vinsn %ilsr-c (((dest :imm)) +(define-ppc32-vinsn %ilsr-c (((dest :imm)) ((count :u8const) (src :imm))) @@ -2403,5 +2369,5 @@ -(define-ppc-vinsn %iasr (((dest :imm)) +(define-ppc32-vinsn %iasr (((dest :imm)) ((count :imm) (src :imm)) @@ -2416,5 +2382,5 @@ (clrrwi dest temp ppc32::fixnumshift)) -(define-ppc-vinsn %iasr-c (((dest :imm)) +(define-ppc32-vinsn %iasr-c (((dest :imm)) ((count :u8const) (src :imm)) @@ -2423,5 +2389,5 @@ (clrrwi dest temp ppc32::fixnumshift)) -(define-ppc-vinsn %ilsr (((dest :imm)) +(define-ppc32-vinsn %ilsr (((dest :imm)) ((count :imm) (src :imm)) @@ -2437,5 +2403,5 @@ ) -(define-ppc-vinsn %ilsr-c (((dest :imm)) +(define-ppc32-vinsn %ilsr-c (((dest :imm)) ((count :u8const) (src :imm)) @@ -2444,20 +2410,20 @@ (clrrwi dest temp ppc32::fixnumshift)) -(define-ppc-vinsn u32-shift-left (((dest :u32)) +(define-ppc32-vinsn u32-shift-left (((dest :u32)) ((src :u32) (count :u8const))) (rlwinm dest src count 0 (:apply - 31 count))) -(define-ppc-vinsn u32-shift-right (((dest :u32)) +(define-ppc32-vinsn u32-shift-right (((dest :u32)) ((src :u32) (count :u8const))) (rlwinm dest src (:apply - 32 count) count 31)) -(define-ppc-vinsn sign-extend-halfword (((dest :imm)) +(define-ppc32-vinsn sign-extend-halfword (((dest :imm)) ((src :imm))) (slwi dest src (- 16 ppc32::fixnumshift)) (srawi dest dest (- 16 ppc32::fixnumshift))) -(define-ppc-vinsn s32-highword (((dest :imm)) +(define-ppc32-vinsn s32-highword (((dest :imm)) ((src :s32)) ((temp :s32))) @@ -2467,5 +2433,5 @@ -(define-ppc-vinsn fixnum-add (((dest t)) +(define-ppc32-vinsn fixnum-add (((dest t)) ((x t) (y t))) @@ -2473,5 +2439,5 @@ -(define-ppc-vinsn fixnum-add-overflow-ool (() +(define-ppc32-vinsn fixnum-add-overflow-ool (() ((x :imm) (y :imm)) @@ -2480,5 +2446,5 @@ (bsola- .SPfix-overflow)) -(define-ppc-vinsn fixnum-add-overflow-inline (((dest :lisp)) +(define-ppc32-vinsn fixnum-add-overflow-inline (((dest :lisp)) ((x :imm) (y :imm)) @@ -2504,10 +2470,10 @@ ; (setq dest (- x y)) -(define-ppc-vinsn fixnum-sub (((dest t)) +(define-ppc32-vinsn fixnum-sub (((dest t)) ((x t) (y t))) (subf dest y x)) -(define-ppc-vinsn fixnum-sub-from-constant (((dest :imm)) +(define-ppc32-vinsn fixnum-sub-from-constant (((dest :imm)) ((x :s16const) (y :imm))) @@ -2517,5 +2483,5 @@ -(define-ppc-vinsn fixnum-sub-overflow-ool (() +(define-ppc32-vinsn fixnum-sub-overflow-ool (() ((x :imm) (y :imm))) @@ -2523,5 +2489,5 @@ (bsola- .SPfix-overflow)) -(define-ppc-vinsn fixnum-sub-overflow-inline (((dest :lisp)) +(define-ppc32-vinsn fixnum-sub-overflow-inline (((dest :lisp)) ((x :imm) (y :imm)) @@ -2544,5 +2510,5 @@ ; This is, of course, also "subtract-immediate." -(define-ppc-vinsn add-immediate (((dest t)) +(define-ppc32-vinsn add-immediate (((dest t)) ((src t) (upper :u32const) @@ -2557,5 +2523,5 @@ ;This must unbox one reg, but hard to tell which is better. ;(The one with the smaller absolute value might be) -(define-ppc-vinsn multiply-fixnums (((dest :imm)) +(define-ppc32-vinsn multiply-fixnums (((dest :imm)) ((a :imm) (b :imm)) @@ -2564,5 +2530,5 @@ (mullw dest a unboxed)) -(define-ppc-vinsn multiply-immediate (((dest :imm)) +(define-ppc32-vinsn multiply-immediate (((dest :imm)) ((boxed :imm) (const :s16const))) @@ -2571,5 +2537,5 @@ ; Mask out the code field of a base character; the result ; should be EXACTLY = to subtag-base-char -(define-ppc-vinsn mask-base-char (((dest :u32)) +(define-ppc32-vinsn mask-base-char (((dest :u32)) ((src :imm))) (rlwinm dest src 0 (1+ (- ppc32::least-significant-bit ppc32::charcode-shift)) (1- (- ppc32::nbits-in-word (+ ppc32::charcode-shift 8))))) @@ -2577,15 +2543,15 @@ ;; Boundp, fboundp stuff. -(define-ppc-vinsn (svar-ref-symbol-value :call :subprim-call) +(define-ppc32-vinsn (svar-ref-symbol-value :call :subprim-call) (((val :lisp)) ((sym (:lisp (:ne val))))) (bla .SPsvar-specrefcheck)) -(define-ppc-vinsn (%svar-ref-symbol-value :call :subprim-call) +(define-ppc32-vinsn (%svar-ref-symbol-value :call :subprim-call) (((val :lisp)) ((sym (:lisp (:ne val))))) (bla .SPsvar-specref)) -(define-ppc-vinsn (svar-setq-special :call :subprim-call) +(define-ppc32-vinsn (svar-setq-special :call :subprim-call) (() ((sym :lisp) @@ -2594,5 +2560,5 @@ -(define-ppc-vinsn symbol-function (((val :lisp)) +(define-ppc32-vinsn symbol-function (((val :lisp)) ((sym (:lisp (:ne val)))) ((crf :crf) @@ -2609,5 +2575,5 @@ :good) -(define-ppc-vinsn (temp-push-unboxed-word :push :word :tsp) +(define-ppc32-vinsn (temp-push-unboxed-word :push :word :tsp) (() ((w :u32))) @@ -2616,5 +2582,5 @@ (stw w 8 ppc::tsp)) -(define-ppc-vinsn (temp-pop-unboxed-word :pop :word :tsp) +(define-ppc32-vinsn (temp-pop-unboxed-word :pop :word :tsp) (((w :u32)) ()) @@ -2622,5 +2588,5 @@ (lwz ppc::tsp 0 ppc::tsp)) -(define-ppc-vinsn (temp-push-double-float :push :doubleword :tsp) +(define-ppc32-vinsn (temp-push-double-float :push :doubleword :tsp) (((d :double-float)) ()) @@ -2629,5 +2595,5 @@ (stfd d 8 ppc::tsp)) -(define-ppc-vinsn (temp-pop-double-float :pop :doubleword :tsp) +(define-ppc32-vinsn (temp-pop-double-float :pop :doubleword :tsp) (() ((d :double-float))) @@ -2635,5 +2601,5 @@ (lwz ppc::tsp 0 ppc::tsp)) -(define-ppc-vinsn (temp-push-single-float :push :word :tsp) +(define-ppc32-vinsn (temp-push-single-float :push :word :tsp) (((s :single-float)) ()) @@ -2642,5 +2608,5 @@ (stfs s 8 ppc::tsp)) -(define-ppc-vinsn (temp-pop-single-float :pop :word :tsp) +(define-ppc32-vinsn (temp-pop-single-float :pop :word :tsp) (() ((s :single-float))) @@ -2649,5 +2615,5 @@ -(define-ppc-vinsn (save-nvrs-individually :push :node :vsp :multiple) +(define-ppc32-vinsn (save-nvrs-individually :push :node :vsp :multiple) (() ((first :u8const))) @@ -2668,5 +2634,5 @@ (stwu ppc::save7 -4 ppc::vsp))))))))) -(define-ppc-vinsn (save-nvrs :push :node :vsp :multiple) +(define-ppc32-vinsn (save-nvrs :push :node :vsp :multiple) (() ((first :u8const))) @@ -2682,5 +2648,5 @@ -(define-ppc-vinsn (restore-nvrs :pop :node :vsp :multiple) +(define-ppc32-vinsn (restore-nvrs :pop :node :vsp :multiple) (() ((firstreg :u8const) @@ -2699,13 +2665,13 @@ (lwz ppc::save0 offset basereg))) -(define-ppc-vinsn %current-frame-ptr (((dest :imm)) +(define-ppc32-vinsn %current-frame-ptr (((dest :imm)) ()) (mr dest ppc::sp)) -(define-ppc-vinsn %current-tcr (((dest :imm)) +(define-ppc32-vinsn %current-tcr (((dest :imm)) ()) (mr dest ppc::rcontext)) -(define-ppc-vinsn (svar-dpayback :call :subprim-call) (() +(define-ppc32-vinsn (svar-dpayback :call :subprim-call) (() ((n :s16const)) ((temp (:u32 #.ppc::imm0)))) @@ -2716,15 +2682,15 @@ (bla .SPsvar-unbind))) -(define-ppc-vinsn zero-double-float-register +(define-ppc32-vinsn zero-double-float-register (((dest :double-float)) ()) (fmr dest ppc::fp-zero)) -(define-ppc-vinsn zero-single-float-register +(define-ppc32-vinsn zero-single-float-register (((dest :single-float)) ()) (fmr dest ppc::fp-zero)) -(define-ppc-vinsn load-double-float-constant +(define-ppc32-vinsn load-double-float-constant (((dest :double-float)) ((high t) @@ -2737,5 +2703,5 @@ (lwz ppc::tsp 0 ppc::tsp)) -(define-ppc-vinsn load-single-float-constant +(define-ppc32-vinsn load-single-float-constant (((dest :single-float)) ((src t))) @@ -2746,23 +2712,23 @@ (lwz ppc::tsp 0 ppc::tsp)) -(define-ppc-vinsn load-indexed-node (((node :lisp)) +(define-ppc32-vinsn load-indexed-node (((node :lisp)) ((base :lisp) (offset :s16const))) (lwz node offset base)) -(define-ppc-vinsn recover-saved-vsp (((dest :imm)) +(define-ppc32-vinsn recover-saved-vsp (((dest :imm)) ()) (lwz dest ppc32::lisp-frame.savevsp ppc::sp)) -(define-ppc-vinsn check-exact-nargs (() +(define-ppc32-vinsn check-exact-nargs (() ((n :u16const))) (twnei ppc::nargs (:apply ash n 2))) -(define-ppc-vinsn check-min-nargs (() +(define-ppc32-vinsn check-min-nargs (() ((min :u16const))) (twllti ppc::nargs (:apply ash min 2))) -(define-ppc-vinsn check-max-nargs (() +(define-ppc32-vinsn check-max-nargs (() ((max :u16const))) (twlgti ppc::nargs (:apply ash max 2))) @@ -2770,5 +2736,5 @@ ; Save context and establish FN. The current VSP is the the ; same as the caller's, e.g., no arguments were vpushed. -(define-ppc-vinsn save-lisp-context-vsp (() +(define-ppc32-vinsn save-lisp-context-vsp (() () ((imm :u32))) @@ -2783,5 +2749,5 @@ ; Do the same thing via a subprim call. -(define-ppc-vinsn (save-lisp-context-vsp-ool :call :subprim-call) +(define-ppc32-vinsn (save-lisp-context-vsp-ool :call :subprim-call) (() () @@ -2789,5 +2755,5 @@ (bla .SPsavecontextvsp)) -(define-ppc-vinsn save-lisp-context-offset (() +(define-ppc32-vinsn save-lisp-context-offset (() ((nbytes-vpushed :u16const)) ((imm :u32))) @@ -2802,5 +2768,5 @@ (twllt ppc::sp imm)) -(define-ppc-vinsn save-lisp-context-offset-ool (() +(define-ppc32-vinsn save-lisp-context-offset-ool (() ((nbytes-vpushed :u16const)) ((imm (:u32 #.ppc::imm0)))) @@ -2809,5 +2775,5 @@ -(define-ppc-vinsn save-lisp-context-lexpr (() +(define-ppc32-vinsn save-lisp-context-lexpr (() () ((imm :u32))) @@ -2821,5 +2787,5 @@ (twllt ppc::sp imm)) -(define-ppc-vinsn save-cleanup-context (() +(define-ppc32-vinsn save-cleanup-context (() ()) ;; SP was this deep just a second ago, so no need to do a stack-probe. @@ -2832,5 +2798,5 @@ ;; Vpush the argument registers. We got at least "min-fixed" args; ;; that knowledge may help us generate better code. -(define-ppc-vinsn (save-lexpr-argregs :call :subprim-call) +(define-ppc32-vinsn (save-lexpr-argregs :call :subprim-call) (() ((min-fixed :u16const)) @@ -2883,10 +2849,10 @@ -(define-ppc-vinsn (jump-return-pc :jumpLR) +(define-ppc32-vinsn (jump-return-pc :jumpLR) (() ()) (blr)) -(define-ppc-vinsn (restore-full-lisp-context :lispcontext :pop :csp :lrRestore) +(define-ppc32-vinsn (restore-full-lisp-context :lispcontext :pop :csp :lrRestore) (() ()) @@ -2897,5 +2863,5 @@ (la ppc::sp ppc32::lisp-frame.size ppc::sp)) -(define-ppc-vinsn (restore-full-lisp-context-ool :lispcontext :pop :csp :lrRestore) +(define-ppc32-vinsn (restore-full-lisp-context-ool :lispcontext :pop :csp :lrRestore) (() ()) @@ -2903,5 +2869,5 @@ (mtlr ppc::loc-pc)) -(define-ppc-vinsn (popj :lispcontext :pop :csp :lrRestore :jumpLR) +(define-ppc32-vinsn (popj :lispcontext :pop :csp :lrRestore :jumpLR) (() ()) @@ -2910,5 +2876,5 @@ ; Exiting from an UNWIND-PROTECT cleanup is similar to ; (and a little simpler than) returning from a function. -(define-ppc-vinsn restore-cleanup-context (() +(define-ppc32-vinsn restore-cleanup-context (() ()) (lwz ppc::loc-pc ppc32::lisp-frame.savelr ppc::sp) @@ -2918,5 +2884,5 @@ -(define-ppc-vinsn default-1-arg (() +(define-ppc32-vinsn default-1-arg (() ((min :u16const)) ((crf :crf))) @@ -2932,5 +2898,5 @@ :done) -(define-ppc-vinsn default-2-args (() +(define-ppc32-vinsn default-2-args (() ((min :u16const)) ((crf :crf))) @@ -2958,5 +2924,5 @@ :done) -(define-ppc-vinsn default-3-args (() +(define-ppc32-vinsn default-3-args (() ((min :u16const)) ((crfx :crf) @@ -2996,5 +2962,5 @@ :done) -(define-ppc-vinsn save-lr (() +(define-ppc32-vinsn save-lr (() ()) (mflr ppc::loc-pc)) @@ -3002,5 +2968,5 @@ ;; "n" is the sum of the number of required args + ;; the number of &optionals. -(define-ppc-vinsn (default-optionals :call :subprim-call) (() +(define-ppc32-vinsn (default-optionals :call :subprim-call) (() ((n :u16const))) (li ppc::imm0 (:apply ash n 2)) @@ -3008,5 +2974,5 @@ ; fname contains a known symbol -(define-ppc-vinsn (call-known-symbol :call) (((result (:lisp ppc::arg_z))) +(define-ppc32-vinsn (call-known-symbol :call) (((result (:lisp ppc::arg_z))) ()) (lwz ppc::nfn ppc32::symbol.fcell ppc::fname) @@ -3015,5 +2981,5 @@ (bctrl)) -(define-ppc-vinsn (jump-known-symbol :jumplr) (() +(define-ppc32-vinsn (jump-known-symbol :jumplr) (() ()) (lwz ppc::nfn ppc32::symbol.fcell ppc::fname) @@ -3022,5 +2988,5 @@ (bctr)) -(define-ppc-vinsn (call-known-function :call) (() +(define-ppc32-vinsn (call-known-function :call) (() ()) (lwz ppc::temp0 ppc32::misc-data-offset ppc::nfn) @@ -3028,5 +2994,5 @@ (bctrl)) -(define-ppc-vinsn (jump-known-function :jumplr) (() +(define-ppc32-vinsn (jump-known-function :jumplr) (() ()) (lwz ppc::temp0 ppc32::misc-data-offset ppc::nfn) @@ -3034,5 +3000,5 @@ (bctr)) -(define-ppc-vinsn %schar (((char :imm)) +(define-ppc32-vinsn %schar (((char :imm)) ((str :lisp) (idx :imm)) @@ -3045,5 +3011,5 @@ (addi char imm ppc32::subtag-character)) -(define-ppc-vinsn %set-schar (() +(define-ppc32-vinsn %set-schar (() ((str :lisp) (idx :imm) @@ -3058,5 +3024,5 @@ ) -(define-ppc-vinsn %set-scharcode (() +(define-ppc32-vinsn %set-scharcode (() ((str :lisp) (idx :imm) @@ -3072,5 +3038,5 @@ -(define-ppc-vinsn %scharcode (((code :imm)) +(define-ppc32-vinsn %scharcode (((code :imm)) ((str :lisp) (idx :imm)) @@ -3083,5 +3049,5 @@ ; Clobbers LR -(define-ppc-vinsn (%debug-trap :call :subprim-call) (() +(define-ppc32-vinsn (%debug-trap :call :subprim-call) (() ()) (bla .SPbreakpoint) @@ -3089,30 +3055,30 @@ -(define-ppc-vinsn eep.address (((dest t)) +(define-ppc32-vinsn eep.address (((dest t)) ((src (:lisp (:ne dest ))))) (lwz dest (+ (ash 1 2) ppc32::misc-data-offset) src) (tweqi dest ppc32::nil-value)) -(define-ppc-vinsn %u32+ (((dest :u32)) +(define-ppc32-vinsn %u32+ (((dest :u32)) ((x :u32) (y :u32))) (add dest x y)) -(define-ppc-vinsn %u32+-c (((dest :u32)) +(define-ppc32-vinsn %u32+-c (((dest :u32)) ((x :u32) (y :u16const))) (addi dest x y)) -(define-ppc-vinsn %u32- (((dest :u32)) +(define-ppc32-vinsn %u32- (((dest :u32)) ((x :u32) (y :u32))) (sub dest x y)) -(define-ppc-vinsn %u32--c (((dest :u32)) +(define-ppc32-vinsn %u32--c (((dest :u32)) ((x :u32) (y :u16const))) (subi dest x y)) -(define-ppc-vinsn %u32-logior (((dest :u32)) +(define-ppc32-vinsn %u32-logior (((dest :u32)) ((x :u32) (y :u32))) (or dest x y)) -(define-ppc-vinsn %u32-logior-c (((dest :u32)) +(define-ppc32-vinsn %u32-logior-c (((dest :u32)) ((x :u32) (high :u16const) (low :u16const))) ((:not (:pred = high 0)) @@ -3121,9 +3087,9 @@ (ori dest x low))) -(define-ppc-vinsn %u32-logxor (((dest :u32)) +(define-ppc32-vinsn %u32-logxor (((dest :u32)) ((x :u32) (y :u32))) (xor dest x y)) -(define-ppc-vinsn %u32-logxor-c (((dest :u32)) +(define-ppc32-vinsn %u32-logxor-c (((dest :u32)) ((x :u32) (high :u16const) (low :u16const))) ((:not (:pred = high 0)) @@ -3132,19 +3098,19 @@ (xori dest x low))) -(define-ppc-vinsn %u32-logand (((dest :u32)) +(define-ppc32-vinsn %u32-logand (((dest :u32)) ((x :u32) (y :u32))) (and dest x y)) -(define-ppc-vinsn %u32-logand-high-c (((dest :u32)) +(define-ppc32-vinsn %u32-logand-high-c (((dest :u32)) ((x :u32) (high :u16const)) ((cr0 (:crf 0)))) (andis. dest x high)) -(define-ppc-vinsn %u32-logand-low-c (((dest :u32)) +(define-ppc32-vinsn %u32-logand-low-c (((dest :u32)) ((x :u32) (low :u16const)) ((cr0 (:crf 0)))) (andi. dest x low)) -(define-ppc-vinsn %u32-logand-mask-c (((dest :u32)) +(define-ppc32-vinsn %u32-logand-mask-c (((dest :u32)) ((x :u32) (start :u8const) @@ -3152,5 +3118,5 @@ (rlwinm dest x 0 start end)) -(define-ppc-vinsn disable-interrupts (((dest :lisp)) +(define-ppc32-vinsn disable-interrupts (((dest :lisp)) () ((temp :imm))) @@ -3160,133 +3126,133 @@ ;;; Subprim calls. Done this way for the benefit of VINSN-OPTIMIZE. -(defmacro define-ppc-subprim-call-vinsn ((name &rest other-attrs) spno) - `(define-ppc-vinsn (,name :call :subprim-call ,@other-attrs) (() ()) +(defmacro define-ppc32-subprim-call-vinsn ((name &rest other-attrs) spno) + `(define-ppc32-vinsn (,name :call :subprim-call ,@other-attrs) (() ()) (bla ,spno))) -(defmacro define-ppc-subprim-jump-vinsn ((name &rest other-attrs) spno) - `(define-ppc-vinsn (,name :jump :jumpLR ,@other-attrs) (() ()) +(defmacro define-ppc32-subprim-jump-vinsn ((name &rest other-attrs) spno) + `(define-ppc32-vinsn (,name :jump :jumpLR ,@other-attrs) (() ()) (ba ,spno))) -(define-ppc-subprim-jump-vinsn (restore-interrupt-level) .SPrestoreintlevel) - -(define-ppc-subprim-call-vinsn (save-values) .SPsave-values) - -(define-ppc-subprim-call-vinsn (recover-values) .SPrecover-values) - -(define-ppc-subprim-call-vinsn (add-values) .SPadd-values) - -(define-ppc-subprim-jump-vinsn (jump-known-symbol-ool) .SPjmpsym) - -(define-ppc-subprim-call-vinsn (call-known-symbol-ool) .SPjmpsym) - -(define-ppc-subprim-call-vinsn (pass-multiple-values) .SPmvpass) - -(define-ppc-subprim-call-vinsn (pass-multiple-values-symbol) .SPmvpasssym) - -(define-ppc-subprim-jump-vinsn (tail-call-sym-gen) .SPtcallsymgen) - -(define-ppc-subprim-jump-vinsn (tail-call-fn-gen) .SPtcallnfngen) - -(define-ppc-subprim-jump-vinsn (tail-call-sym-slide) .SPtcallsymslide) - -(define-ppc-subprim-jump-vinsn (tail-call-fn-slide) .SPtcallnfnslide) - -(define-ppc-subprim-jump-vinsn (tail-call-sym-vsp) .SPtcallsymvsp) - -(define-ppc-subprim-jump-vinsn (tail-call-fn-vsp) .SPtcallnfnvsp) - -(define-ppc-subprim-call-vinsn (funcall) .SPfuncall) - -(define-ppc-subprim-jump-vinsn (tail-funcall-gen) .SPtfuncallgen) - -(define-ppc-subprim-jump-vinsn (tail-funcall-slide) .SPtfuncallslide) - -(define-ppc-subprim-jump-vinsn (tail-funcall-vsp) .SPtfuncallvsp) - -(define-ppc-subprim-call-vinsn (spread-lexpr) .SPspread-lexpr-z) - -(define-ppc-subprim-call-vinsn (spread-list) .SPspreadargz) - -(define-ppc-subprim-call-vinsn (pop-argument-registers) .SPvpopargregs) - -(define-ppc-subprim-call-vinsn (getxlong) .SPgetXlong) - -(define-ppc-subprim-call-vinsn (stack-cons-list) .SPstkconslist) - -(define-ppc-subprim-call-vinsn (list) .SPconslist) - -(define-ppc-subprim-call-vinsn (stack-cons-list*) .SPstkconslist-star) - -(define-ppc-subprim-call-vinsn (list*) .SPconslist-star) - -(define-ppc-subprim-call-vinsn (make-stack-block) .SPmakestackblock) - -(define-ppc-subprim-call-vinsn (make-stack-block0) .Spmakestackblock0) - -(define-ppc-subprim-call-vinsn (make-stack-list) .Spmakestacklist) - -(define-ppc-subprim-call-vinsn (make-stack-vector) .SPmkstackv) - -(define-ppc-subprim-call-vinsn (make-stack-gvector) .SPstkgvector) - -(define-ppc-subprim-call-vinsn (stack-misc-alloc) .SPstack-misc-alloc) - -(define-ppc-subprim-call-vinsn (stack-misc-alloc-init) .SPstack-misc-alloc-init) - -(define-ppc-subprim-call-vinsn (svar-bind-nil) .SPsvar-bind-nil) - -(define-ppc-subprim-call-vinsn (svar-bind-self) .SPsvar-bind-self) - -(define-ppc-subprim-call-vinsn (svar-bind-self-boundp-check) .SPsvar-bind-self-boundp-check) - -(define-ppc-subprim-call-vinsn (svar-bind) .SPsvar-bind) - -(define-ppc-subprim-jump-vinsn (nvalret :jumpLR) .SPnvalret) - -(define-ppc-subprim-call-vinsn (nthrowvalues) .SPnthrowvalues) - -(define-ppc-subprim-call-vinsn (nthrow1value) .SPnthrow1value) - -(define-ppc-subprim-call-vinsn (slide-values) .SPmvslide) - -(define-ppc-subprim-call-vinsn (macro-bind) .SPmacro-bind) - -(define-ppc-subprim-call-vinsn (destructuring-bind-inner) .SPdestructuring-bind-inner) - -(define-ppc-subprim-call-vinsn (destructuring-bind) .SPdestructuring-bind) - -(define-ppc-subprim-call-vinsn (simple-keywords) .SPsimple-keywords) - -(define-ppc-subprim-call-vinsn (keyword-args) .SPkeyword-args) - -(define-ppc-subprim-call-vinsn (keyword-bind) .SPkeyword-bind) - -(define-ppc-subprim-call-vinsn (stack-rest-arg) .SPstack-rest-arg) - -(define-ppc-subprim-call-vinsn (req-stack-rest-arg) .SPreq-stack-rest-arg) - -(define-ppc-subprim-call-vinsn (stack-cons-rest-arg) .SPstack-cons-rest-arg) - -(define-ppc-subprim-call-vinsn (heap-rest-arg) .SPheap-rest-arg) - -(define-ppc-subprim-call-vinsn (req-heap-rest-arg) .SPreq-heap-rest-arg) - -(define-ppc-subprim-call-vinsn (heap-cons-rest-arg) .SPheap-cons-rest-arg) - -(define-ppc-subprim-call-vinsn (opt-supplied-p) .SPopt-supplied-p) - -(define-ppc-subprim-call-vinsn (gvector) .SPgvector) - -(define-ppc-vinsn (nth-value :call :subprim-call) (((result :lisp)) +(define-ppc32-subprim-jump-vinsn (restore-interrupt-level) .SPrestoreintlevel) + +(define-ppc32-subprim-call-vinsn (save-values) .SPsave-values) + +(define-ppc32-subprim-call-vinsn (recover-values) .SPrecover-values) + +(define-ppc32-subprim-call-vinsn (add-values) .SPadd-values) + +(define-ppc32-subprim-jump-vinsn (jump-known-symbol-ool) .SPjmpsym) + +(define-ppc32-subprim-call-vinsn (call-known-symbol-ool) .SPjmpsym) + +(define-ppc32-subprim-call-vinsn (pass-multiple-values) .SPmvpass) + +(define-ppc32-subprim-call-vinsn (pass-multiple-values-symbol) .SPmvpasssym) + +(define-ppc32-subprim-jump-vinsn (tail-call-sym-gen) .SPtcallsymgen) + +(define-ppc32-subprim-jump-vinsn (tail-call-fn-gen) .SPtcallnfngen) + +(define-ppc32-subprim-jump-vinsn (tail-call-sym-slide) .SPtcallsymslide) + +(define-ppc32-subprim-jump-vinsn (tail-call-fn-slide) .SPtcallnfnslide) + +(define-ppc32-subprim-jump-vinsn (tail-call-sym-vsp) .SPtcallsymvsp) + +(define-ppc32-subprim-jump-vinsn (tail-call-fn-vsp) .SPtcallnfnvsp) + +(define-ppc32-subprim-call-vinsn (funcall) .SPfuncall) + +(define-ppc32-subprim-jump-vinsn (tail-funcall-gen) .SPtfuncallgen) + +(define-ppc32-subprim-jump-vinsn (tail-funcall-slide) .SPtfuncallslide) + +(define-ppc32-subprim-jump-vinsn (tail-funcall-vsp) .SPtfuncallvsp) + +(define-ppc32-subprim-call-vinsn (spread-lexpr) .SPspread-lexpr-z) + +(define-ppc32-subprim-call-vinsn (spread-list) .SPspreadargz) + +(define-ppc32-subprim-call-vinsn (pop-argument-registers) .SPvpopargregs) + +(define-ppc32-subprim-call-vinsn (getxlong) .SPgetXlong) + +(define-ppc32-subprim-call-vinsn (stack-cons-list) .SPstkconslist) + +(define-ppc32-subprim-call-vinsn (list) .SPconslist) + +(define-ppc32-subprim-call-vinsn (stack-cons-list*) .SPstkconslist-star) + +(define-ppc32-subprim-call-vinsn (list*) .SPconslist-star) + +(define-ppc32-subprim-call-vinsn (make-stack-block) .SPmakestackblock) + +(define-ppc32-subprim-call-vinsn (make-stack-block0) .Spmakestackblock0) + +(define-ppc32-subprim-call-vinsn (make-stack-list) .Spmakestacklist) + +(define-ppc32-subprim-call-vinsn (make-stack-vector) .SPmkstackv) + +(define-ppc32-subprim-call-vinsn (make-stack-gvector) .SPstkgvector) + +(define-ppc32-subprim-call-vinsn (stack-misc-alloc) .SPstack-misc-alloc) + +(define-ppc32-subprim-call-vinsn (stack-misc-alloc-init) .SPstack-misc-alloc-init) + +(define-ppc32-subprim-call-vinsn (svar-bind-nil) .SPsvar-bind-nil) + +(define-ppc32-subprim-call-vinsn (svar-bind-self) .SPsvar-bind-self) + +(define-ppc32-subprim-call-vinsn (svar-bind-self-boundp-check) .SPsvar-bind-self-boundp-check) + +(define-ppc32-subprim-call-vinsn (svar-bind) .SPsvar-bind) + +(define-ppc32-subprim-jump-vinsn (nvalret :jumpLR) .SPnvalret) + +(define-ppc32-subprim-call-vinsn (nthrowvalues) .SPnthrowvalues) + +(define-ppc32-subprim-call-vinsn (nthrow1value) .SPnthrow1value) + +(define-ppc32-subprim-call-vinsn (slide-values) .SPmvslide) + +(define-ppc32-subprim-call-vinsn (macro-bind) .SPmacro-bind) + +(define-ppc32-subprim-call-vinsn (destructuring-bind-inner) .SPdestructuring-bind-inner) + +(define-ppc32-subprim-call-vinsn (destructuring-bind) .SPdestructuring-bind) + +(define-ppc32-subprim-call-vinsn (simple-keywords) .SPsimple-keywords) + +(define-ppc32-subprim-call-vinsn (keyword-args) .SPkeyword-args) + +(define-ppc32-subprim-call-vinsn (keyword-bind) .SPkeyword-bind) + +(define-ppc32-subprim-call-vinsn (stack-rest-arg) .SPstack-rest-arg) + +(define-ppc32-subprim-call-vinsn (req-stack-rest-arg) .SPreq-stack-rest-arg) + +(define-ppc32-subprim-call-vinsn (stack-cons-rest-arg) .SPstack-cons-rest-arg) + +(define-ppc32-subprim-call-vinsn (heap-rest-arg) .SPheap-rest-arg) + +(define-ppc32-subprim-call-vinsn (req-heap-rest-arg) .SPreq-heap-rest-arg) + +(define-ppc32-subprim-call-vinsn (heap-cons-rest-arg) .SPheap-cons-rest-arg) + +(define-ppc32-subprim-call-vinsn (opt-supplied-p) .SPopt-supplied-p) + +(define-ppc32-subprim-call-vinsn (gvector) .SPgvector) + +(define-ppc32-vinsn (nth-value :call :subprim-call) (((result :lisp)) ()) (bla .SPnthvalue)) -(define-ppc-subprim-call-vinsn (fitvals) .SPfitvals) - -(define-ppc-subprim-call-vinsn (misc-alloc) .SPmisc-alloc) - -(define-ppc-subprim-call-vinsn (misc-alloc-init) .SPmisc-alloc-init) - -(define-ppc-subprim-call-vinsn (integer-sign) .SPinteger-sign) +(define-ppc32-subprim-call-vinsn (fitvals) .SPfitvals) + +(define-ppc32-subprim-call-vinsn (misc-alloc) .SPmisc-alloc) + +(define-ppc32-subprim-call-vinsn (misc-alloc-init) .SPmisc-alloc-init) + +(define-ppc32-subprim-call-vinsn (integer-sign) .SPinteger-sign) ;;; Even though it's implemented by calling a subprim, THROW is really @@ -3294,59 +3260,59 @@ ;;; really known, it should probably be inlined (stack-cleanup, value ;;; transfer & jump ...) -(define-ppc-vinsn (throw :jump :jump-unknown) (() +(define-ppc32-vinsn (throw :jump :jump-unknown) (() ()) (bla .SPthrow)) -(define-ppc-subprim-call-vinsn (mkcatchmv) .SPmkcatchmv) - -(define-ppc-subprim-call-vinsn (mkcatch1v) .SPmkcatch1v) - -(define-ppc-subprim-call-vinsn (setqsym) .SPsvar-setqsym) - -(define-ppc-subprim-call-vinsn (ksignalerr) .SPksignalerr) - -(define-ppc-subprim-call-vinsn (subtag-misc-ref) .SPsubtag-misc-ref) - -(define-ppc-subprim-call-vinsn (subtag-misc-set) .SPsubtag-misc-set) - -(define-ppc-subprim-call-vinsn (mkunwind) .SPmkunwind) - -(define-ppc-subprim-call-vinsn (progvsave) .SPsvar-progvsave) - -(define-ppc-subprim-jump-vinsn (progvrestore) .SPsvar-progvrestore) - -(define-ppc-subprim-call-vinsn (syscall) .SPsyscall) - -(define-ppc-subprim-call-vinsn (newblocktag) .SPnewblocktag) - -(define-ppc-subprim-call-vinsn (newgotag) .SPnewgotag) - -(define-ppc-subprim-call-vinsn (misc-ref) .SPmisc-ref) - -(define-ppc-subprim-call-vinsn (misc-set) .SPmisc-set) - -(define-ppc-subprim-call-vinsn (gets64) .SPgets64) - -(define-ppc-subprim-call-vinsn (getu64) .SPgetu64) - -(define-ppc-subprim-call-vinsn (makeu64) .SPmakeu64) - -(define-ppc-subprim-call-vinsn (makes64) .SPmakes64) - -(define-ppc-vinsn (darwin-syscall :call :subprim-call) (() +(define-ppc32-subprim-call-vinsn (mkcatchmv) .SPmkcatchmv) + +(define-ppc32-subprim-call-vinsn (mkcatch1v) .SPmkcatch1v) + +(define-ppc32-subprim-call-vinsn (setqsym) .SPsvar-setqsym) + +(define-ppc32-subprim-call-vinsn (ksignalerr) .SPksignalerr) + +(define-ppc32-subprim-call-vinsn (subtag-misc-ref) .SPsubtag-misc-ref) + +(define-ppc32-subprim-call-vinsn (subtag-misc-set) .SPsubtag-misc-set) + +(define-ppc32-subprim-call-vinsn (mkunwind) .SPmkunwind) + +(define-ppc32-subprim-call-vinsn (progvsave) .SPsvar-progvsave) + +(define-ppc32-subprim-jump-vinsn (progvrestore) .SPsvar-progvrestore) + +(define-ppc32-subprim-call-vinsn (syscall) .SPsyscall) + +(define-ppc32-subprim-call-vinsn (newblocktag) .SPnewblocktag) + +(define-ppc32-subprim-call-vinsn (newgotag) .SPnewgotag) + +(define-ppc32-subprim-call-vinsn (misc-ref) .SPmisc-ref) + +(define-ppc32-subprim-call-vinsn (misc-set) .SPmisc-set) + +(define-ppc32-subprim-call-vinsn (gets64) .SPgets64) + +(define-ppc32-subprim-call-vinsn (getu64) .SPgetu64) + +(define-ppc32-subprim-call-vinsn (makeu64) .SPmakeu64) + +(define-ppc32-subprim-call-vinsn (makes64) .SPmakes64) + +(define-ppc32-vinsn (darwin-syscall :call :subprim-call) (() ()) (stw ppc::rzero ppc32::c-frame.crsave ppc::sp) (bla .SPdarwin-syscall)) -(define-ppc-vinsn (darwin-syscall-s64 :call :subprim-call) (() +(define-ppc32-vinsn (darwin-syscall-s64 :call :subprim-call) (() ()) (stw ppc::sp ppc32::c-frame.crsave ppc::sp) (bla .SPdarwin-syscall)) -(define-ppc-subprim-call-vinsn (eabi-ff-call) .SPeabi-ff-call) - -(define-ppc-subprim-call-vinsn (poweropen-ff-call) .SPffcall) - -(define-ppc-subprim-call-vinsn (poweropen-ff-callX) .SPffcallX) +(define-ppc32-subprim-call-vinsn (eabi-ff-call) .SPeabi-ff-call) + +(define-ppc32-subprim-call-vinsn (poweropen-ff-call) .SPffcall) + +(define-ppc32-subprim-call-vinsn (poweropen-ff-callX) .SPffcallX)