From 232b5aad81c55eee750398b7ee241a63a3727aa2 Mon Sep 17 00:00:00 2001 From: dtc <dtc> Date: Wed, 21 Jan 1998 05:10:20 +0000 Subject: [PATCH] Complex-float support for the sparc backend. --- compiler/sparc/array.lisp | 109 +++++++++++- compiler/sparc/float.lisp | 306 +++++++++++++++++++++++++++++++++- compiler/sparc/type-vops.lisp | 60 ++++++- compiler/sparc/vm.lisp | 23 ++- 4 files changed, 486 insertions(+), 12 deletions(-) diff --git a/compiler/sparc/array.lisp b/compiler/sparc/array.lisp index 11b529824..b26877371 100644 --- a/compiler/sparc/array.lisp +++ b/compiler/sparc/array.lisp @@ -5,13 +5,15 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/array.lisp,v 1.15 1997/04/02 19:18:59 dtc Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/array.lisp,v 1.16 1998/01/21 05:10:20 dtc Exp $") ;;; ;;; ********************************************************************** ;;; ;;; This file contains the SPARC definitions for array operations. ;;; ;;; Written by William Lott +;;; Signed-array support by Douglas Crosher 1997. +;;; Complex-float support by Douglas Crosher 1998. ;;; (in-package "SPARC") @@ -492,3 +494,108 @@ (value :scs (signed-reg))) (:results (result :scs (signed-reg))) (:result-types tagged-num)) + + +;;; Complex float arrays. +#+complex-float +(progn + +(define-vop (data-vector-ref/simple-array-complex-single-float) + (:note "inline array access") + (:translate data-vector-ref) + (:policy :fast-safe) + (:args (object :scs (descriptor-reg)) + (index :scs (any-reg))) + (:arg-types simple-array-complex-single-float positive-fixnum) + (:results (value :scs (complex-single-reg))) + (:temporary (:scs (non-descriptor-reg)) offset) + (:result-types complex-single-float) + (:generator 5 + (let ((real-tn (complex-single-reg-real-tn value))) + (inst sll offset index 1) + (inst add offset (- (* vm:vector-data-offset vm:word-bytes) + vm:other-pointer-type)) + (inst ldf real-tn object offset)) + (let ((imag-tn (complex-single-reg-imag-tn value))) + (inst add offset vm:word-bytes) + (inst ldf imag-tn object offset)))) + +(define-vop (data-vector-set/simple-array-complex-single-float) + (:note "inline array store") + (:translate data-vector-set) + (:policy :fast-safe) + (:args (object :scs (descriptor-reg)) + (index :scs (any-reg)) + (value :scs (complex-single-reg) :target result)) + (:arg-types simple-array-complex-single-float positive-fixnum + complex-single-float) + (:results (result :scs (complex-single-reg))) + (:result-types complex-single-float) + (:temporary (:scs (non-descriptor-reg)) offset) + (:generator 5 + (let ((value-real (complex-single-reg-real-tn value)) + (result-real (complex-single-reg-real-tn result))) + (inst sll offset index 1) + (inst add offset (- (* vm:vector-data-offset vm:word-bytes) + vm:other-pointer-type)) + (inst stf value-real object offset) + (unless (location= result-real value-real) + (inst fmovs result-real value-real))) + (let ((value-imag (complex-single-reg-imag-tn value)) + (result-imag (complex-single-reg-imag-tn result))) + (inst add offset vm:word-bytes) + (inst stf value-imag object offset) + (unless (location= result-imag value-imag) + (inst fmovs result-imag value-imag))))) + +(define-vop (data-vector-ref/simple-array-complex-double-float) + (:note "inline array access") + (:translate data-vector-ref) + (:policy :fast-safe) + (:args (object :scs (descriptor-reg)) + (index :scs (any-reg))) + (:arg-types simple-array-complex-double-float positive-fixnum) + (:results (value :scs (complex-double-reg))) + (:result-types complex-double-float) + (:temporary (:scs (non-descriptor-reg)) offset) + (:generator 7 + (let ((real-tn (complex-double-reg-real-tn value))) + (inst sll offset index 2) + (inst add offset (- (* vm:vector-data-offset vm:word-bytes) + vm:other-pointer-type)) + (inst lddf real-tn object offset)) + (let ((imag-tn (complex-double-reg-imag-tn value))) + (inst add offset (* 2 vm:word-bytes)) + (inst lddf imag-tn object offset)))) + +(define-vop (data-vector-set/simple-array-complex-double-float) + (:note "inline array store") + (:translate data-vector-set) + (:policy :fast-safe) + (:args (object :scs (descriptor-reg)) + (index :scs (any-reg)) + (value :scs (complex-double-reg) :target result)) + (:arg-types simple-array-complex-double-float positive-fixnum + complex-double-float) + (:results (result :scs (complex-double-reg))) + (:result-types complex-double-float) + (:temporary (:scs (non-descriptor-reg)) offset) + (:generator 20 + (let ((value-real (complex-double-reg-real-tn value)) + (result-real (complex-double-reg-real-tn result))) + (inst sll offset index 2) + (inst add offset (- (* vm:vector-data-offset vm:word-bytes) + vm:other-pointer-type)) + (inst stdf value-real object offset) + (unless (location= result-real value-real) + (inst fmovs result-real value-real) + (inst fmovs-odd result-real value-real))) + (let ((value-imag (complex-double-reg-imag-tn value)) + (result-imag (complex-double-reg-imag-tn result))) + (inst add offset (* 2 vm:word-bytes)) + (inst stdf value-imag object offset) + (unless (location= result-imag value-imag) + (inst fmovs result-imag value-imag) + (inst fmovs-odd result-imag value-imag))))) + +) ; end progn complex-float diff --git a/compiler/sparc/float.lisp b/compiler/sparc/float.lisp index 055f8166d..5ed09c803 100644 --- a/compiler/sparc/float.lisp +++ b/compiler/sparc/float.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/float.lisp,v 1.12 1994/10/31 04:46:41 ram Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/float.lisp,v 1.13 1998/01/21 05:10:19 dtc Exp $") ;;; ;;; ********************************************************************** ;;; @@ -13,6 +13,7 @@ ;;; ;;; Written by Rob MacLachlan ;;; Sparc conversion by William Lott. +;;; Complex-float support by Douglas Crosher 1998. ;;; (in-package "SPARC") @@ -124,9 +125,216 @@ (frob move-single-float-argument single-reg single-stack nil) (frob move-double-float-argument double-reg double-stack t)) + +;;;; Complex float move functions +#+complex-float +(progn + +(defun complex-single-reg-real-tn (x) + (make-random-tn :kind :normal :sc (sc-or-lose 'single-reg *backend*) + :offset (tn-offset x))) +(defun complex-single-reg-imag-tn (x) + (make-random-tn :kind :normal :sc (sc-or-lose 'single-reg *backend*) + :offset (1+ (tn-offset x)))) + +(defun complex-double-reg-real-tn (x) + (make-random-tn :kind :normal :sc (sc-or-lose 'double-reg *backend*) + :offset (tn-offset x))) +(defun complex-double-reg-imag-tn (x) + (make-random-tn :kind :normal :sc (sc-or-lose 'double-reg *backend*) + :offset (1+ (tn-offset x)))) + + +(define-move-function (load-complex-single 2) (vop x y) + ((complex-single-stack) (complex-single-reg)) + (let ((real-tn (complex-single-reg-real-tn y))) + (inst ldf real-tn (current-nfp-tn vop) (* (tn-offset x) vm:word-bytes))) + (let ((imag-tn (complex-single-reg-imag-tn y))) + (inst ldf imag-tn (current-nfp-tn vop) (* (1+ (tn-offset x)) + vm:word-bytes)))) + +(define-move-function (store-complex-single 2) (vop x y) + ((complex-single-reg) (complex-single-stack)) + (let ((real-tn (complex-single-reg-real-tn x))) + (inst stf real-tn (current-nfp-tn vop) (* (tn-offset y) vm:word-bytes))) + (let ((imag-tn (complex-single-reg-imag-tn x))) + (inst stf imag-tn (current-nfp-tn vop) (* (1+ (tn-offset y)) + vm:word-bytes)))) + + +(define-move-function (load-complex-double 4) (vop x y) + ((complex-double-stack) (complex-double-reg)) + (let ((nfp (current-nfp-tn vop)) + (offset (* (tn-offset x) vm:word-bytes))) + (let ((real-tn (complex-double-reg-real-tn y))) + (inst lddf real-tn nfp offset)) + (let ((imag-tn (complex-double-reg-imag-tn y))) + (inst lddf imag-tn nfp (+ offset (* 2 vm:word-bytes)))))) + +(define-move-function (store-complex-double 4) (vop x y) + ((complex-double-reg) (complex-double-stack)) + (let ((nfp (current-nfp-tn vop)) + (offset (* (tn-offset y) vm:word-bytes))) + (let ((real-tn (complex-double-reg-real-tn x))) + (inst stdf real-tn nfp offset)) + (let ((imag-tn (complex-double-reg-imag-tn x))) + (inst stdf imag-tn nfp (+ offset (* 2 vm:word-bytes)))))) + +;;; +;;; Complex float register to register moves. +;;; +(define-vop (complex-single-move) + (:args (x :scs (complex-single-reg) :target y + :load-if (not (location= x y)))) + (:results (y :scs (complex-single-reg) :load-if (not (location= x y)))) + (:note "complex single float move") + (:generator 0 + (unless (location= x y) + ;; Note the complex-float-regs are aligned to every second + ;; float register so there is not need to worry about overlap. + (let ((x-real (complex-single-reg-real-tn x)) + (y-real (complex-single-reg-real-tn y))) + (inst fmovs y-real x-real)) + (let ((x-imag (complex-single-reg-imag-tn x)) + (y-imag (complex-single-reg-imag-tn y))) + (inst fmovs y-imag x-imag))))) +;;; +(define-move-vop complex-single-move :move + (complex-single-reg) (complex-single-reg)) + +(define-vop (complex-double-move) + (:args (x :scs (complex-double-reg) + :target y :load-if (not (location= x y)))) + (:results (y :scs (complex-double-reg) :load-if (not (location= x y)))) + (:note "complex double float move") + (:generator 0 + (unless (location= x y) + ;; Note the complex-float-regs are aligned to every second + ;; float register so there is not need to worry about overlap. + (let ((x-real (complex-double-reg-real-tn x)) + (y-real (complex-double-reg-real-tn y))) + (inst fmovs y-real x-real) + (inst fmovs-odd y-real x-real)) + (let ((x-imag (complex-double-reg-imag-tn x)) + (y-imag (complex-double-reg-imag-tn y))) + (inst fmovs y-imag x-imag) + (inst fmovs-odd y-imag x-imag))))) +;;; +(define-move-vop complex-double-move :move + (complex-double-reg) (complex-double-reg)) + +;;; +;;; Move from a complex float to a descriptor register allocating a +;;; new complex float object in the process. +;;; +(define-vop (move-from-complex-single) + (:args (x :scs (complex-single-reg) :to :save)) + (:results (y :scs (descriptor-reg))) + (:temporary (:scs (non-descriptor-reg)) ndescr) + (:note "complex single float to pointer coercion") + (:generator 13 + (with-fixed-allocation (y ndescr vm:complex-single-float-type + vm:complex-single-float-size)) + (let ((real-tn (complex-single-reg-real-tn x))) + (inst stf real-tn y (- (* vm:complex-single-float-real-slot + vm:word-bytes) + vm:other-pointer-type))) + (let ((imag-tn (complex-single-reg-imag-tn x))) + (inst stf imag-tn y (- (* vm:complex-single-float-imag-slot + vm:word-bytes) + vm:other-pointer-type))))) +;;; +(define-move-vop move-from-complex-single :move + (complex-single-reg) (descriptor-reg)) + +(define-vop (move-from-complex-double) + (:args (x :scs (complex-double-reg) :to :save)) + (:results (y :scs (descriptor-reg))) + (:temporary (:scs (non-descriptor-reg)) ndescr) + (:note "complex double float to pointer coercion") + (:generator 13 + (with-fixed-allocation (y ndescr vm:complex-double-float-type + vm:complex-double-float-size)) + (let ((real-tn (complex-double-reg-real-tn x))) + (inst stdf real-tn y (- (* vm:complex-double-float-real-slot + vm:word-bytes) + vm:other-pointer-type))) + (let ((imag-tn (complex-double-reg-imag-tn x))) + (inst stdf imag-tn y (- (* vm:complex-double-float-imag-slot + vm:word-bytes) + vm:other-pointer-type))))) +;;; +(define-move-vop move-from-complex-double :move + (complex-double-reg) (descriptor-reg)) + +;;; +;;; Move from a descriptor to a complex float register +;;; +(macrolet ((frob (name sc double-p real-value imag-value) + `(progn + (define-vop (,name) + (:args (x :scs (descriptor-reg))) + (:results (y :scs (,sc))) + (:note "pointer to complex float coercion") + (:generator 2 + (let ((real-tn (complex-double-reg-real-tn y))) + (inst ,(if double-p 'lddf 'ldf) real-tn x + (- (* ,real-value vm:word-bytes) + vm:other-pointer-type))) + (let ((imag-tn (complex-double-reg-imag-tn y))) + (inst ,(if double-p 'lddf 'ldf) imag-tn x + (- (* ,imag-value vm:word-bytes) + vm:other-pointer-type))))) + (define-move-vop ,name :move (descriptor-reg) (,sc))))) + (frob move-to-complex-single complex-single-reg nil + complex-single-float-real-slot complex-single-float-imag-slot) + (frob move-to-complex-double complex-double-reg t + complex-double-float-real-slot complex-double-float-imag-slot)) +;;; +;;; Complex float move-argument vop +;;; +(macrolet ((frob (name sc stack-sc double-p) + `(progn + (define-vop (,name) + (:args (x :scs (,sc) :target y) + (nfp :scs (any-reg) + :load-if (not (sc-is y ,sc)))) + (:results (y)) + (:note "float argument move") + (:generator ,(if double-p 2 1) + (sc-case y + (,sc + (unless (location= x y) + (let ((x-real (complex-double-reg-real-tn x)) + (y-real (complex-double-reg-real-tn y))) + (inst fmovs y-real x-real) + ,@(when double-p + '((inst fmovs-odd y-real x-real)))) + (let ((x-imag (complex-double-reg-imag-tn x)) + (y-imag (complex-double-reg-imag-tn y))) + (inst fmovs y-imag x-imag) + ,@(when double-p + '((inst fmovs-odd y-imag x-imag)))))) + (,stack-sc + (let ((offset (* (tn-offset y) vm:word-bytes))) + (let ((real-tn (complex-double-reg-real-tn x))) + (inst ,(if double-p 'stdf 'stf) real-tn nfp offset)) + (let ((imag-tn (complex-double-reg-imag-tn x))) + (inst ,(if double-p 'stdf 'stf) imag-tn nfp offset))))))) + (define-move-vop ,name :move-argument + (,sc descriptor-reg) (,sc))))) + (frob move-complex-single-float-argument + complex-single-reg complex-single-stack nil) + (frob move-complex-double-float-argument + complex-double-reg complex-double-stack t)) + +) ; progn complex-float + (define-move-vop move-argument :move-argument - (single-reg double-reg) (descriptor-reg)) + (single-reg double-reg + #+complex-float complex-single-reg #+complex-float complex-double-reg) + (descriptor-reg)) ;;;; Arithmetic VOPs: @@ -516,3 +724,97 @@ (storew new nfp (tn-offset temp)) (inst ldfsr nfp (* word-bytes (tn-offset temp))) (move res new)))) + + +;;;; Complex float VOPs + +#+complex-float +(progn + +(define-vop (make-complex-single-float) + (:translate complex) + (:args (x :scs (single-reg) :target r) + (y :scs (single-reg) :to :save)) + (:arg-types single-float single-float) + (:results (r :scs (complex-single-reg) :from (:argument 0))) + (:result-types complex-single-float) + (:note "inline complex single-float creation") + (:policy :fast-safe) + (:generator 5 + (let ((r-real (complex-single-reg-real-tn r))) + (unless (location= x r-real) + (inst fmovs r-real x))) + (let ((r-imag (complex-single-reg-imag-tn r))) + (unless (location= y r-imag) + (inst fmovs r-imag y))))) + +(define-vop (make-complex-double-float) + (:translate complex) + (:args (x :scs (double-reg) :target r) + (y :scs (double-reg) :to :save)) + (:arg-types double-float double-float) + (:results (r :scs (complex-double-reg) :from (:argument 0))) + (:result-types complex-double-float) + (:note "inline complex double-float creation") + (:policy :fast-safe) + (:generator 5 + (let ((r-real (complex-double-reg-real-tn r))) + (unless (location= x r-real) + (inst fmovs r-real x) + (inst fmovs-odd r-real x))) + (let ((r-imag (complex-double-reg-imag-tn r))) + (unless (location= y r-imag) + (inst fmovs r-imag y) + (inst fmovs-odd r-imag y))))) + + +(define-vop (complex-single-float-value) + (:args (x :scs (complex-single-reg) :target r)) + (:arg-types complex-single-float) + (:results (r :scs (single-reg))) + (:result-types single-float) + (:variant-vars offset) + (:policy :fast-safe) + (:generator 3 + (let ((value-tn (make-random-tn :kind :normal + :sc (sc-or-lose 'single-reg *backend*) + :offset (+ offset (tn-offset x))))) + (unless (location= value-tn r) + (inst fmovs r value-tn))))) + +(define-vop (realpart/complex-single-float complex-single-float-value) + (:translate realpart) + (:note "complex single float realpart") + (:variant 0)) + +(define-vop (imagpart/complex-single-float complex-single-float-value) + (:translate imagpart) + (:note "complex single float imagpart") + (:variant 1)) + +(define-vop (complex-double-float-value) + (:args (x :scs (complex-double-reg) :target r)) + (:arg-types complex-double-float) + (:results (r :scs (double-reg))) + (:result-types double-float) + (:variant-vars offset) + (:policy :fast-safe) + (:generator 3 + (let ((value-tn (make-random-tn :kind :normal + :sc (sc-or-lose 'double-reg *backend*) + :offset (+ offset (tn-offset x))))) + (unless (location= value-tn r) + (inst fmovs r value-tn) + (inst fmovs-odd r value-tn))))) + +(define-vop (realpart/complex-double-float complex-double-float-value) + (:translate realpart) + (:note "complex double float realpart") + (:variant 0)) + +(define-vop (imagpart/complex-double-float complex-double-float-value) + (:translate imagpart) + (:note "complex double float imagpart") + (:variant 2)) + +) ; progn complex-float diff --git a/compiler/sparc/type-vops.lisp b/compiler/sparc/type-vops.lisp index 1d1d4dcad..0e27541ed 100644 --- a/compiler/sparc/type-vops.lisp +++ b/compiler/sparc/type-vops.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/type-vops.lisp,v 1.16 1997/04/21 20:01:25 dtc Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/type-vops.lisp,v 1.17 1998/01/21 05:10:18 dtc Exp $") ;;; ;;; ********************************************************************** ;;; @@ -13,6 +13,8 @@ ;;; for the SPARC. ;;; ;;; Written by William Lott. +;;; Signed-array support by Douglas Crosher 1997. +;;; Complex-float support by Douglas Crosher 1998. ;;; (in-package "SPARC") @@ -108,8 +110,29 @@ (def-type-vops ratiop check-ratio ratio object-not-ratio-error vm:ratio-type) -(def-type-vops complexp check-complex complex - object-not-complex-error vm:complex-type) +(def-type-vops complexp check-complex complex object-not-complex-error + vm:complex-type + #+complex-float vm:complex-single-float-type + #+complex-float vm:complex-double-float-type) + +#+complex-float +(def-type-vops complex-rational-p check-complex-rational nil + object-not-complex-rational-error vm:complex-type) + +#+complex-float +(def-type-vops complex-float-p check-complex-float nil + object-not-complex-float-error + vm:complex-single-float-type vm:complex-double-float-type) + +#+complex-float +(def-type-vops complex-single-float-p check-complex-single-float + complex-single-float object-not-complex-single-float-error + vm:complex-single-float-type) + +#+complex-float +(def-type-vops complex-double-float-p check-complex-double-float + complex-double-float object-not-complex-double-float-error + vm:complex-double-float-type) (def-type-vops single-float-p check-single-float single-float object-not-single-float-error vm:single-float-type) @@ -192,6 +215,20 @@ simple-array-double-float object-not-simple-array-double-float-error vm:simple-array-double-float-type) +#+complex-float +(def-type-vops simple-array-complex-single-float-p + check-simple-array-complex-single-float + simple-array-complex-single-float + object-not-simple-array-complex-single-float-error + vm:simple-array-complex-single-float-type) + +#+complex-float +(def-type-vops simple-array-complex-double-float-p + check-simple-array-complex-double-float + simple-array-complex-double-float + object-not-simple-array-complex-double-float-error + vm:simple-array-complex-double-float-type) + (def-type-vops base-char-p check-base-char base-char object-not-base-char-error vm:base-char-type) @@ -241,9 +278,10 @@ #+signed-array simple-array-signed-byte-16-type #+signed-array simple-array-signed-byte-30-type #+signed-array simple-array-signed-byte-32-type - vm:simple-array-single-float-type - vm:simple-array-double-float-type vm:complex-string-type - vm:complex-bit-vector-type vm:complex-vector-type) + vm:simple-array-single-float-type vm:simple-array-double-float-type + #+complex-float vm:simple-array-complex-single-float-type + #+complex-float vm:simple-array-complex-double-float-type + vm:complex-string-type vm:complex-bit-vector-type vm:complex-vector-type) (def-type-vops simple-array-p check-simple-array nil object-not-simple-array-error vm:simple-array-type vm:simple-string-type vm:simple-bit-vector-type @@ -254,7 +292,9 @@ #+signed-array simple-array-signed-byte-16-type #+signed-array simple-array-signed-byte-30-type #+signed-array simple-array-signed-byte-32-type - vm:simple-array-single-float-type vm:simple-array-double-float-type) + vm:simple-array-single-float-type vm:simple-array-double-float-type + #+complex-float vm:simple-array-complex-single-float-type + #+complex-float vm:simple-array-complex-double-float-type) (def-type-vops arrayp check-array nil object-not-array-error vm:simple-array-type vm:simple-string-type vm:simple-bit-vector-type @@ -266,12 +306,16 @@ #+signed-array simple-array-signed-byte-30-type #+signed-array simple-array-signed-byte-32-type vm:simple-array-single-float-type vm:simple-array-double-float-type + #+complex-float vm:simple-array-complex-single-float-type + #+complex-float vm:simple-array-complex-double-float-type vm:complex-string-type vm:complex-bit-vector-type vm:complex-vector-type vm:complex-array-type) (def-type-vops numberp check-number nil object-not-number-error vm:even-fixnum-type vm:odd-fixnum-type vm:bignum-type vm:ratio-type - vm:single-float-type vm:double-float-type vm:complex-type) + vm:single-float-type vm:double-float-type vm:complex-type + #+complex-float vm:complex-single-float-type + #+complex-float vm:complex-double-float-type) (def-type-vops rationalp check-rational nil object-not-rational-error vm:even-fixnum-type vm:odd-fixnum-type vm:ratio-type vm:bignum-type) diff --git a/compiler/sparc/vm.lisp b/compiler/sparc/vm.lisp index 874ce697a..8b9e47c91 100644 --- a/compiler/sparc/vm.lisp +++ b/compiler/sparc/vm.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/vm.lisp,v 1.7 1994/10/31 04:46:41 ram Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/vm.lisp,v 1.8 1998/01/21 05:10:17 dtc Exp $") ;;; ;;; ********************************************************************** ;;; @@ -148,6 +148,11 @@ (single-stack non-descriptor-stack) ; single-floats (double-stack non-descriptor-stack :element-size 2 :alignment 2) ; double floats. + #+complex-float + (complex-single-stack stack :element-size 2) ; complex-single-floats + #+complex-float + (complex-double-stack stack + :element-size 4 :alignment 2) ; complex-double-floats. ;; **** Things that can go in the integer registers. @@ -223,6 +228,22 @@ :save-p t :alternate-scs (double-stack)) + #+complex-float + (complex-single-reg float-registers + :locations (0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30) + :element-size 2 + :constant-scs () + :save-p t + :alternate-scs (complex-single-stack)) + + #+complex-float + (complex-double-reg float-registers + :locations (0 4 8 12 16 20 24 28) + :element-size 4 + :constant-scs () + :save-p t + :alternate-scs (complex-double-stack)) + ;; A catch or unwind block. (catch-block control-stack :element-size vm:catch-block-size)) -- GitLab