X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fhppa%2Fcall.lisp;h=be8e880b509b3c61a602bce6390878acc765ffc2;hb=69e6aef5e6fb3bd682c7a2cbf774034d2ea58ee8;hp=ff31fe14df755564e78f9e41375306b3c9558b45;hpb=0d74ed478e7f3af5d3292153726373763631aa8e;p=sbcl.git diff --git a/src/compiler/hppa/call.lisp b/src/compiler/hppa/call.lisp index ff31fe1..be8e880 100644 --- a/src/compiler/hppa/call.lisp +++ b/src/compiler/hppa/call.lisp @@ -15,7 +15,7 @@ ;;; Return a wired TN describing the N'th full call argument passing ;;; location. -(!def-vm-support-routine standard-arg-location (n) +(defun standard-arg-location (n) (declare (type unsigned-byte n)) (if (< n register-arg-count) (make-wired-tn *backend-t-primitive-type* @@ -29,7 +29,7 @@ ;;; true, then use the standard (full call) location, otherwise use any legal ;;; location. Even in the non-standard case, this may be restricted by a ;;; desire to use a subroutine call instruction. -(!def-vm-support-routine make-return-pc-passing-location (standard) +(defun make-return-pc-passing-location (standard) (if standard (make-wired-tn *backend-t-primitive-type* register-arg-scn lra-offset) (make-restricted-tn *backend-t-primitive-type* register-arg-scn))) @@ -39,7 +39,7 @@ ;;; standard convention, but is totally unrestricted in non-standard ;;; conventions, since we can always fetch it off of the stack using ;;; the arg pointer. -(!def-vm-support-routine make-old-fp-passing-location (standard) +(defun make-old-fp-passing-location (standard) (if standard (make-wired-tn *fixnum-primitive-type* immediate-arg-scn ocfp-offset) (make-normal-tn *fixnum-primitive-type*))) @@ -47,14 +47,14 @@ ;;; Make the TNs used to hold OLD-FP and RETURN-PC within the current ;;; function. We treat these specially so that the debugger can find ;;; them at a known location. -(!def-vm-support-routine make-old-fp-save-location (env) +(defun make-old-fp-save-location (env) (specify-save-tn (physenv-debug-live-tn (make-normal-tn *fixnum-primitive-type*) env) (make-wired-tn *fixnum-primitive-type* control-stack-arg-scn ocfp-save-offset))) -(!def-vm-support-routine make-return-pc-save-location (env) +(defun make-return-pc-save-location (env) (let ((ptype *backend-t-primitive-type*)) (specify-save-tn (physenv-debug-live-tn (make-normal-tn ptype) env) @@ -63,25 +63,25 @@ ;;; Make a TN for the standard argument count passing location. We only ;;; need to make the standard location, since a count is never passed when we ;;; are using non-standard conventions. -(!def-vm-support-routine make-arg-count-location () +(defun make-arg-count-location () (make-wired-tn *fixnum-primitive-type* immediate-arg-scn nargs-offset)) ;;; Make a TN to hold the number-stack frame pointer. This is allocated ;;; once per component, and is component-live. -(!def-vm-support-routine make-nfp-tn () +(defun make-nfp-tn () (component-live-tn (make-wired-tn *fixnum-primitive-type* immediate-arg-scn nfp-offset))) -(!def-vm-support-routine make-stack-pointer-tn () +(defun make-stack-pointer-tn () (make-normal-tn *fixnum-primitive-type*)) -(!def-vm-support-routine make-number-stack-pointer-tn () +(defun make-number-stack-pointer-tn () (make-normal-tn *fixnum-primitive-type*)) ;;; Return a list of TNs that can be used to represent an unknown-values ;;; continuation within a function. -(!def-vm-support-routine make-unknown-values-locations () +(defun make-unknown-values-locations () (list (make-stack-pointer-tn) (make-normal-tn *fixnum-primitive-type*))) @@ -90,7 +90,7 @@ ;;; VM-dependent initialization of the IR2-COMPONENT structure. We push ;;; placeholder entries in the Constants to leave room for additional ;;; noise in the code object header. -(!def-vm-support-routine select-component-format (component) +(defun select-component-format (component) (declare (type component component)) (dotimes (i code-constants-offset) (vector-push-extend nil @@ -127,6 +127,24 @@ (inst addi (- (bytes-needed-for-non-descriptor-stack-frame)) nfp val))))) +;;; Accessing a slot from an earlier stack frame is definite hackery. +(define-vop (ancestor-frame-ref) + (:args (frame-pointer :scs (descriptor-reg)) + (variable-home-tn :load-if nil)) + (:results (value :scs (descriptor-reg any-reg))) + (:policy :fast-safe) + (:generator 4 + (aver (sc-is variable-home-tn control-stack)) + (loadw value frame-pointer (tn-offset variable-home-tn)))) +(define-vop (ancestor-frame-set) + (:args (frame-pointer :scs (descriptor-reg)) + (value :scs (descriptor-reg any-reg))) + (:results (variable-home-tn :load-if nil)) + (:policy :fast-safe) + (:generator 4 + (aver (sc-is variable-home-tn control-stack)) + (storew value frame-pointer (tn-offset variable-home-tn)))) + (define-vop (xep-allocate-frame) (:info start-lab copy-more-arg-follows) (:ignore copy-more-arg-follows) @@ -399,6 +417,15 @@ default-value-8 nvals) (:temporary (:scs (non-descriptor-reg)) temp)) + +;;; This hook in the codegen pass lets us insert code before fall-thru entry +;;; points, local-call entry points, and tail-call entry points. The default +;;; does nothing. +(defun emit-block-header (start-label trampoline-label fall-thru-p alignp) + (declare (ignore fall-thru-p alignp)) + (when trampoline-label + (emit-label trampoline-label)) + (emit-label start-label)) ;;;; Local call with unknown values convention return: @@ -774,12 +801,7 @@ default-value-8 (insert-step-instrumenting (callable-tn) ;; Conditionally insert a conditional trap: (when step-instrumenting - ;; Get the symbol-value of SB!IMPL::*STEPPING* - (inst ldw (- (+ symbol-value-slot - (truncate (static-symbol-offset 'sb!impl::*stepping*) - n-word-bytes)) - other-pointer-lowtag) - null-tn stepping) + (load-symbol-value stepping sb!impl::*stepping*) ;; If it's not NIL, trap. ;(inst comb := stepping null-tn step-done-label) (inst comb := null-tn null-tn step-done-label :nullify t) @@ -1025,10 +1047,13 @@ default-value-8 (lisp-return lra-arg :offset 2) ;; Nope, not the single case. (emit-label not-single) + ;; most of these moves will not be emitted and therefor + ;; isn't suitable to put in the delay slot below. But if + ;; you do, dont forget to force-emit as in (move src dst t) (move ocfp-arg ocfp) (move lra-arg lra) (move vals-arg vals) - (move nvals-arg nvals) ; FIX-lav: cant utilize branch-delay-slot, why? + (move nvals-arg nvals) (let ((fixup (make-fixup 'return-multiple :assembly-routine))) (inst ldil fixup tmp) (inst be fixup lisp-heap-space tmp :nullify t))) @@ -1061,7 +1086,7 @@ default-value-8 ;;; Copy a more arg from the argument area to the end of the current frame. ;;; Fixed is the number of non-more arguments. -;;; FIX-lav: old hppa code look smarter. +;;; FIXME-lav: old hppa code look smarter. (define-vop (copy-more-arg) (:temporary (:sc any-reg :offset nl0-offset) result) (:temporary (:sc any-reg :offset nl1-offset) count) @@ -1097,11 +1122,11 @@ default-value-8 (inst add nargs-tn cfp-tn src) (emit-label loop) - ; decrease src, then load src into temp + ;; decrease src, then load src into temp (inst ldwm (- n-word-bytes) src temp) - ; increase, compare if count >= to zero, if true, jump + ;; increase, compare if count >= to zero, if true, jump (inst addib :>= (fixnumize -1) count loop) - ; decrease dst, then store temp at dst + ;; decrease dst, then store temp at dst (inst stwm temp (- n-word-bytes) dst) (emit-label do-regs) @@ -1252,12 +1277,7 @@ default-value-8 (:policy :fast-safe) (:vop-var vop) (:generator 3 - ;; Get the symbol-value of SB!IMPL::*STEPPING* - (inst ldw (- (+ symbol-value-slot - (truncate (static-symbol-offset 'sb!impl::*stepping*) - n-word-bytes)) - other-pointer-lowtag) - null-tn stepping) + (load-symbol-value stepping sb!impl::*stepping*) ;; If it's not NIL, trap. (inst comb := stepping null-tn DONE :nullify t) ;; CONTEXT-PC will be pointing here when the interrupt is handled,