;;; bytes on the PMAX.
(defun bytes-needed-for-non-descriptor-stack-frame ()
(* (logandc2 (1+ (sb-allocated-size 'non-descriptor-stack)) 1)
- word-bytes))
+ n-word-bytes))
;;; This is used for setting up the Old-FP in local call.
(define-vop (current-fp)
(:generator 1
;; Make sure the function is aligned, and drop a label pointing to
;; this function header.
- (align lowtag-bits)
+ (align n-lowtag-bits)
(trace-table-entry trace-table-function-prologue)
(emit-label start-lab)
;; Allocate function header.
;; collector won't forget about us if we call anyone else.
)
;; Build our stack frames.
- (inst lda csp-tn (* word-bytes (sb-allocated-size 'control-stack)) cfp-tn)
+ (inst lda
+ csp-tn
+ (* n-word-bytes (sb-allocated-size 'control-stack))
+ cfp-tn)
(let ((nfp (current-nfp-tn vop)))
(when nfp
(inst subq nsp-tn (bytes-needed-for-non-descriptor-stack-frame)
(:generator 2
(trace-table-entry trace-table-function-prologue)
(move csp-tn res)
- (inst lda csp-tn (* word-bytes (sb-allocated-size 'control-stack)) csp-tn)
+ (inst lda
+ csp-tn
+ (* n-word-bytes (sb-allocated-size 'control-stack))
+ csp-tn)
(when (ir2-physenv-number-stack-p callee)
(inst subq nsp-tn (bytes-needed-for-non-descriptor-stack-frame)
nsp-tn)
(:generator 2
(when (> nargs register-arg-count)
(move csp-tn res)
- (inst lda csp-tn (* nargs word-bytes) csp-tn))))
+ (inst lda csp-tn (* nargs n-word-bytes) csp-tn))))
;;; Emit code needed at the return-point from an unknown-values call
;;; for a fixed number of values. Values is the head of the TN-Ref
(defaults (cons default-lab tn))
(inst blt temp default-lab)
- (inst ldl move-temp (* i word-bytes) ocfp-tn)
+ (inst ldl move-temp (* i n-word-bytes) ocfp-tn)
(inst subq temp (fixnumize 1) temp)
(store-stack-tn tn move-temp)))
(when cur-nfp
(inst addq cur-nfp (bytes-needed-for-non-descriptor-stack-frame)
nsp-tn)))
- (inst subq return-pc-temp (- other-pointer-type word-bytes) lip)
+ (inst subq return-pc-temp (- other-pointer-lowtag n-word-bytes) lip)
(move ocfp-temp cfp-tn)
(inst ret zero-tn lip 1)
(trace-table-entry trace-table-normal)))
(constant
(inst ldl name-pass
(- (ash (tn-offset name) word-shift)
- other-pointer-type) code-tn)
+ other-pointer-lowtag) code-tn)
(do-next-filler)))
(inst ldl entry-point
(- (ash fdefn-raw-addr-slot word-shift)
- other-pointer-type) name-pass)
+ other-pointer-lowtag) name-pass)
(do-next-filler))
`((sc-case arg-fun
(descriptor-reg (move arg-fun lexenv))
(constant
(inst ldl lexenv
(- (ash (tn-offset arg-fun) word-shift)
- other-pointer-type) code-tn)
+ other-pointer-lowtag) code-tn)
(do-next-filler)))
#!-gengc
(inst ldl function
(- (ash closure-fun-slot word-shift)
- fun-pointer-type) lexenv)
+ fun-pointer-lowtag) lexenv)
#!-gengc
(do-next-filler)
#!-gengc
(inst addq function
(- (ash simple-fun-code-offset word-shift)
- fun-pointer-type) entry-point)
+ fun-pointer-lowtag) entry-point)
#!+gengc
(inst ldl entry-point
(- (ash closure-entry-point-slot word-shift)
- fun-pointer-type) lexenv)
+ fun-pointer-lowtag) lexenv)
#!+gengc
(do-next-filler)))
(loop
#!-gengc (lisp-return return-pc lip :offset 2)
#!+gengc
(progn
- (inst addq return-pc (* 2 word-bytes) temp)
+ (inst addq return-pc (* 2 n-word-bytes) temp)
(unless (location= ra return-pc)
(inst move ra return-pc))
(inst ret zero-tn temp 1))
;; restore the frame pointer and clear as much of the control
;; stack as possible.
(move ocfp cfp-tn)
- (inst addq val-ptr (* nvals word-bytes) csp-tn)
+ (inst addq val-ptr (* nvals n-word-bytes) csp-tn)
;; pre-default any argument register that need it.
(when (< nvals register-arg-count)
(dolist (reg (subseq (list a0 a1 a2 a3 a4 a5) nvals))
(emit-label loop)
;; *--dst = *--src, --count
- (inst subq src word-bytes src)
+ (inst subq src n-word-bytes src)
(inst subq count (fixnumize 1) count)
(loadw temp src)
- (inst subq dst word-bytes dst)
+ (inst subq dst n-word-bytes dst)
(storew temp dst)
(inst bgt count loop)
;; We need to do this atomically.
(pseudo-atomic ()
;; Allocate a cons (2 words) for each item.
- (inst bis alloc-tn list-pointer-type result)
+ (inst bis alloc-tn list-pointer-lowtag result)
(move result dst)
(inst sll count 1 temp)
(inst addq alloc-tn temp alloc-tn)
;; Store the current cons in the cdr of the previous cons.
(emit-label loop)
- (inst addq dst (* 2 word-bytes) dst)
- (storew dst dst -1 list-pointer-type)
+ (inst addq dst (* 2 n-word-bytes) dst)
+ (storew dst dst -1 list-pointer-lowtag)
(emit-label enter)
;; Grab one value.
(loadw temp context)
- (inst addq context word-bytes context)
+ (inst addq context n-word-bytes context)
;; Store the value in the car (in delay slot)
- (storew temp dst 0 list-pointer-type)
+ (storew temp dst 0 list-pointer-lowtag)
;; Decrement count, and if != zero, go back for more.
(inst subq count (fixnumize 1) count)
(inst bne count loop)
;; NIL out the last cons.
- (storew null-tn dst 1 list-pointer-type))
+ (storew null-tn dst 1 list-pointer-lowtag))
(emit-label done))))
;;; Return the location and size of the &MORE arg glob created by