-(in-package "SB!VM")
+;;;; allocation VOPs for the HPPA
+
+;;;; This software is part of the SBCL system. See the README file for
+;;;; more information.
+;;;;
+;;;; This software is derived from the CMU CL system, which was
+;;;; written at Carnegie Mellon University and released into the
+;;;; public domain. The software is in the public domain and is
+;;;; provided with absolutely no warranty. See the COPYING and CREDITS
+;;;; files for more information.
+(in-package "SB!VM")
\f
;;;; LIST and LIST*
-
(define-vop (list-or-list*)
(:args (things :more t))
(:temporary (:scs (descriptor-reg) :type list) ptr)
(:results (result :scs (descriptor-reg)))
(:variant-vars star)
(:policy :safe)
+ (:node-var node)
(:generator 0
- (cond
- ((zerop num)
- (move null-tn result))
- ((and star (= num 1))
- (move (tn-ref-tn things) result))
- (t
- (macrolet
- ((maybe-load (tn)
- (once-only ((tn tn))
- `(sc-case ,tn
- ((any-reg descriptor-reg zero null)
- ,tn)
- (control-stack
- (load-stack-tn temp ,tn)
- temp)))))
- (let* ((cons-cells (if star (1- num) num))
- (alloc (* (pad-data-block cons-size) cons-cells)))
- (pseudo-atomic (:extra alloc)
- (move alloc-tn res)
- (inst dep list-pointer-lowtag 31 3 res)
- (move res ptr)
- (dotimes (i (1- cons-cells))
- (storew (maybe-load (tn-ref-tn things)) ptr
- cons-car-slot list-pointer-lowtag)
- (setf things (tn-ref-across things))
- (inst addi (pad-data-block cons-size) ptr ptr)
- (storew ptr ptr
- (- cons-cdr-slot cons-size)
- list-pointer-lowtag))
- (storew (maybe-load (tn-ref-tn things)) ptr
- cons-car-slot list-pointer-lowtag)
- (storew (if star
- (maybe-load (tn-ref-tn (tn-ref-across things)))
- null-tn)
- ptr cons-cdr-slot list-pointer-lowtag))
- (move res result)))))))
-
+ (cond ((zerop num)
+ (move null-tn result))
+ ((and star (= num 1))
+ (move (tn-ref-tn things) result))
+ (t
+ (macrolet
+ ((store-car (tn list &optional (slot cons-car-slot))
+ `(let ((reg (sc-case ,tn
+ ((any-reg descriptor-reg zero null) ,tn)
+ (control-stack
+ (load-stack-tn temp ,tn)
+ temp))))
+ (storew reg ,list ,slot list-pointer-lowtag))))
+ (let* ((dx-p (node-stack-allocate-p node))
+ (cons-cells (if star (1- num) num))
+ (alloc (* (pad-data-block cons-size) cons-cells)))
+ (pseudo-atomic (:extra (if dx-p 0 alloc))
+ (when dx-p
+ (align-csp res))
+ (set-lowtag list-pointer-lowtag (if dx-p csp-tn alloc-tn) res)
+ (when dx-p
+ (inst addi alloc csp-tn csp-tn))
+ (move res ptr)
+ (dotimes (i (1- cons-cells))
+ (store-car (tn-ref-tn things) ptr)
+ (setf things (tn-ref-across things))
+ (inst addi (pad-data-block cons-size) ptr ptr)
+ (storew ptr ptr
+ (- cons-cdr-slot cons-size)
+ list-pointer-lowtag))
+ (store-car (tn-ref-tn things) ptr)
+ (cond (star
+ (setf things (tn-ref-across things))
+ (store-car (tn-ref-tn things) ptr cons-cdr-slot))
+ (t
+ (storew null-tn ptr
+ cons-cdr-slot list-pointer-lowtag)))
+ (aver (null (tn-ref-across things)))
+ (move res result))))))))
(define-vop (list list-or-list*)
(:variant nil))
\f
;;;; Special purpose inline allocators.
+;;; ALLOCATE-VECTOR
+(define-vop (allocate-vector-on-heap)
+ (:args (type :scs (unsigned-reg))
+ (length :scs (any-reg))
+ (words :scs (any-reg)))
+ (:arg-types positive-fixnum
+ positive-fixnum
+ positive-fixnum)
+ (:temporary (:sc non-descriptor-reg) bytes)
+ (:results (result :scs (descriptor-reg) :from :load))
+ (:policy :fast-safe)
+ (:generator 100
+ (inst addi (+ lowtag-mask
+ (* vector-data-offset n-word-bytes)) words bytes)
+ (inst dep 0 31 n-lowtag-bits bytes)
+ (pseudo-atomic ()
+ (set-lowtag other-pointer-lowtag alloc-tn result)
+ (inst add bytes alloc-tn alloc-tn)
+ (storew type result 0 other-pointer-lowtag)
+ (storew length result vector-length-slot other-pointer-lowtag))))
+
+(define-vop (allocate-vector-on-stack)
+ (:args (type :scs (unsigned-reg))
+ (length :scs (any-reg))
+ (words :scs (any-reg)))
+ (:arg-types positive-fixnum
+ positive-fixnum
+ positive-fixnum)
+ (:temporary (:sc non-descriptor-reg) bytes temp)
+ (:results (result :scs (descriptor-reg) :from :load))
+ (:policy :fast-safe)
+ (:generator 100
+ (inst addi (+ lowtag-mask
+ (* vector-data-offset n-word-bytes)) words bytes)
+ (inst dep 0 31 n-lowtag-bits bytes)
+ ;; FIXME: It would be good to check for stack overflow here.
+ (pseudo-atomic ()
+ (align-csp temp)
+ (set-lowtag other-pointer-lowtag csp-tn result)
+ (inst addi (* vector-data-offset n-word-bytes) csp-tn temp)
+ (inst add bytes csp-tn csp-tn)
+ (storew type result 0 other-pointer-lowtag)
+ (storew length result vector-length-slot other-pointer-lowtag)
+ (let ((loop (gen-label)))
+ (emit-label loop)
+ (inst comb :<> temp csp-tn loop :nullify t)
+ (inst stwm zero-tn n-word-bytes temp)))))
(define-vop (allocate-code-object)
(:args (boxed-arg :scs (any-reg))
(:temporary (:scs (non-descriptor-reg) :from (:argument 1)) unboxed)
(:generator 100
(inst addi (fixnumize (1+ code-trace-table-offset-slot)) boxed-arg boxed)
- (inst dep 0 31 3 boxed)
+ (inst dep 0 31 n-lowtag-bits boxed)
(inst srl unboxed-arg word-shift unboxed)
(inst addi lowtag-mask unboxed unboxed)
- (inst dep 0 31 3 unboxed)
+ (inst dep 0 31 n-lowtag-bits unboxed)
+ (inst sll boxed (- n-widetag-bits word-shift) ndescr)
+ (inst addi code-header-widetag ndescr ndescr)
(pseudo-atomic ()
- ;; Note: we don't have to subtract off the 4 that was added by
- ;; pseudo-atomic, because depositing other-pointer-lowtag just adds
- ;; it right back.
- (inst move alloc-tn result)
- (inst dep other-pointer-lowtag 31 3 result)
+ (set-lowtag other-pointer-lowtag alloc-tn result)
(inst add alloc-tn boxed alloc-tn)
(inst add alloc-tn unboxed alloc-tn)
- (inst sll boxed (- n-widetag-bits word-shift) ndescr)
- (inst addi code-header-widetag ndescr ndescr)
(storew ndescr result 0 other-pointer-lowtag)
(storew unboxed result code-code-size-slot other-pointer-lowtag)
(storew null-tn result code-entry-points-slot other-pointer-lowtag)
(storew null-tn result code-debug-info-slot other-pointer-lowtag))))
(define-vop (make-fdefn)
+ (:translate make-fdefn)
+ (:policy :fast-safe)
(:args (name :scs (descriptor-reg) :to :eval))
(:temporary (:scs (non-descriptor-reg)) temp)
(:results (result :scs (descriptor-reg) :from :argument))
- (:policy :fast-safe)
- (:translate make-fdefn)
(:generator 37
- (with-fixed-allocation (result temp fdefn-widetag fdefn-size)
+ (with-fixed-allocation (result nil temp fdefn-widetag fdefn-size nil)
(inst li (make-fixup "undefined_tramp" :foreign) temp)
(storew name result fdefn-name-slot other-pointer-lowtag)
(storew null-tn result fdefn-fun-slot other-pointer-lowtag)
(define-vop (make-closure)
(:args (function :to :save :scs (descriptor-reg)))
(:info length stack-allocate-p)
- (:ignore stack-allocate-p)
(:temporary (:scs (non-descriptor-reg)) temp)
(:results (result :scs (descriptor-reg)))
(:generator 10
- (let ((size (+ length closure-info-offset)))
- (pseudo-atomic (:extra (pad-data-block size))
- (inst move alloc-tn result)
- (inst dep fun-pointer-lowtag 31 3 result)
- (inst li (logior (ash (1- size) n-widetag-bits) closure-header-widetag) temp)
- (storew temp result 0 fun-pointer-lowtag)))
- (storew function result closure-fun-slot fun-pointer-lowtag)))
+ (with-fixed-allocation
+ (result nil temp closure-header-widetag
+ (+ length closure-info-offset)
+ stack-allocate-p :lowtag fun-pointer-lowtag)
+ (storew function result closure-fun-slot fun-pointer-lowtag))))
;;; The compiler likes to be able to directly make value cells.
-;;;
(define-vop (make-value-cell)
(:args (value :to :save :scs (descriptor-reg any-reg)))
(:temporary (:scs (non-descriptor-reg)) temp)
(:results (result :scs (descriptor-reg)))
+ (:info stack-allocate-p)
(:generator 10
(with-fixed-allocation
- (result temp value-cell-header-widetag value-cell-size))
- (storew value result value-cell-value-slot other-pointer-lowtag)))
-
-
+ (result nil temp value-cell-header-widetag value-cell-size stack-allocate-p)
+ (storew value result value-cell-value-slot other-pointer-lowtag))))
\f
;;;; Automatic allocators for primitive objects.
(define-vop (make-unbound-marker)
(:args)
- (:results (result :scs (any-reg)))
+ (:results (result :scs (descriptor-reg any-reg)))
(:generator 1
(inst li unbound-marker-widetag result)))
+(define-vop (make-funcallable-instance-tramp)
+ (:args)
+ (:results (result :scs (any-reg)))
+ (:generator 1
+ (inst li (make-fixup 'funcallable-instance-tramp :assembly-routine)
+ result)))
+
(define-vop (fixed-alloc)
(:args)
- (:info name words type lowtag)
+ (:info name words type lowtag stack-allocate-p)
(:ignore name)
(:results (result :scs (descriptor-reg)))
(:temporary (:scs (non-descriptor-reg)) temp)
(:generator 4
- (pseudo-atomic (:extra (pad-data-block words))
- (inst move alloc-tn result)
- (inst dep lowtag 31 3 result)
- (when type
- (inst li (logior (ash (1- words) n-widetag-bits) type) temp)
- (storew temp result 0 lowtag)))))
+ (with-fixed-allocation
+ (result nil temp type words stack-allocate-p
+ :lowtag lowtag :maybe-write t))))
(define-vop (var-alloc)
(:args (extra :scs (any-reg)))
(inst addi (* (1+ words) n-word-bytes) extra bytes)
(inst sll bytes (- n-widetag-bits 2) header)
(inst addi (+ (ash -2 n-widetag-bits) type) header header)
- (inst dep 0 31 3 bytes)
+ (inst dep 0 31 n-lowtag-bits bytes)
(pseudo-atomic ()
- (inst move alloc-tn result)
- (inst dep lowtag 31 3 result)
+ (set-lowtag lowtag alloc-tn result)
(storew header result 0 lowtag)
(inst add alloc-tn bytes alloc-tn))))
+
projects / sbcl.git / blobdiff