X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fsparc%2Fparms.lisp;h=b6c6306f6705d44de62a50884858c5e804adbb49;hb=35fecfc13c93b85d30a23375ca2850cbbf4a923e;hp=51e3efd161627b1d3361451f609e43fb4ef28f25;hpb=68fd2d2dd6f265669a8957accd8a33e62786a97e;p=sbcl.git diff --git a/src/compiler/sparc/parms.lisp b/src/compiler/sparc/parms.lisp index 51e3efd..b6c6306 100644 --- a/src/compiler/sparc/parms.lisp +++ b/src/compiler/sparc/parms.lisp @@ -12,86 +12,84 @@ ;;;; Machine Architecture parameters: (eval-when (:compile-toplevel :load-toplevel :execute) -(defconstant n-word-bits 32 +(def!constant n-word-bits 32 #!+sb-doc "Number of bits per word where a word holds one lisp descriptor.") -(defconstant n-byte-bits 8 +(def!constant n-byte-bits 8 #!+sb-doc "Number of bits per byte where a byte is the smallest addressable object.") -(defconstant word-shift (1- (integer-length (/ n-word-bits n-byte-bits))) +(def!constant word-shift (1- (integer-length (/ n-word-bits n-byte-bits))) #!+sb-doc "Number of bits to shift between word addresses and byte addresses.") -(defconstant n-word-bytes (/ n-word-bits n-byte-bits) +(def!constant n-word-bytes (/ n-word-bits n-byte-bits) #!+sb-doc "Number of bytes in a word.") -;;; FIXME: The following three should probably be rationalized or at -;;; least prefixed with n- where applicable -(defconstant fixnum-tag-bits (1- n-lowtag-bits) +(def!constant n-fixnum-tag-bits (1- n-lowtag-bits) #!+sb-doc "Number of tag bits used for a fixnum") -(defconstant fixnum-tag-mask (1- (ash 1 fixnum-tag-bits)) +(def!constant fixnum-tag-mask (1- (ash 1 n-fixnum-tag-bits)) #!+sb-doc "Mask to get the fixnum tag") -(defconstant positive-fixnum-bits (- n-word-bits fixnum-tag-bits 1) +(def!constant n-positive-fixnum-bits (- n-word-bits n-fixnum-tag-bits 1) #!+sb-doc "Maximum number of bits in a positive fixnum") -(defconstant float-sign-shift 31) +(def!constant float-sign-shift 31) -(defconstant single-float-bias 126) +(def!constant single-float-bias 126) (defconstant-eqx single-float-exponent-byte (byte 8 23) #'equalp) (defconstant-eqx single-float-significand-byte (byte 23 0) #'equalp) -(defconstant single-float-normal-exponent-min 1) -(defconstant single-float-normal-exponent-max 254) -(defconstant single-float-hidden-bit (ash 1 23)) -(defconstant single-float-trapping-nan-bit (ash 1 22)) +(def!constant single-float-normal-exponent-min 1) +(def!constant single-float-normal-exponent-max 254) +(def!constant single-float-hidden-bit (ash 1 23)) +(def!constant single-float-trapping-nan-bit (ash 1 22)) -(defconstant double-float-bias 1022) +(def!constant double-float-bias 1022) (defconstant-eqx double-float-exponent-byte (byte 11 20) #'equalp) (defconstant-eqx double-float-significand-byte (byte 20 0) #'equalp) -(defconstant double-float-normal-exponent-min 1) -(defconstant double-float-normal-exponent-max #x7FE) -(defconstant double-float-hidden-bit (ash 1 20)) -(defconstant double-float-trapping-nan-bit (ash 1 19)) +(def!constant double-float-normal-exponent-min 1) +(def!constant double-float-normal-exponent-max #x7FE) +(def!constant double-float-hidden-bit (ash 1 20)) +(def!constant double-float-trapping-nan-bit (ash 1 19)) ;;; CMUCL COMMENT: ;;; X These values are for the x86 80 bit format and are no doubt ;;; incorrect for the sparc. ;;; FIXME -(defconstant long-float-bias 16382) +(def!constant long-float-bias 16382) (defconstant-eqx long-float-exponent-byte (byte 15 0) #'equalp) (defconstant-eqx long-float-significand-byte (byte 31 0) #'equalp) -(defconstant long-float-normal-exponent-min 1) -(defconstant long-float-normal-exponent-max #x7FFE) -(defconstant long-float-hidden-bit (ash 1 31)) -(defconstant long-float-trapping-nan-bit (ash 1 30)) +(def!constant long-float-normal-exponent-min 1) +(def!constant long-float-normal-exponent-max #x7FFE) +(def!constant long-float-hidden-bit (ash 1 31)) +(def!constant long-float-trapping-nan-bit (ash 1 30)) -(defconstant single-float-digits +(def!constant single-float-digits (+ (byte-size single-float-significand-byte) 1)) -(defconstant double-float-digits +(def!constant double-float-digits (+ (byte-size double-float-significand-byte) n-word-bits 1)) ;;; This looks wrong - CSR -(defconstant long-float-digits +(def!constant long-float-digits (+ (byte-size long-float-significand-byte) n-word-bits 1)) -(defconstant float-inexact-trap-bit (ash 1 0)) -(defconstant float-divide-by-zero-trap-bit (ash 1 1)) -(defconstant float-underflow-trap-bit (ash 1 2)) -(defconstant float-overflow-trap-bit (ash 1 3)) -(defconstant float-invalid-trap-bit (ash 1 4)) +(def!constant float-inexact-trap-bit (ash 1 0)) +(def!constant float-divide-by-zero-trap-bit (ash 1 1)) +(def!constant float-underflow-trap-bit (ash 1 2)) +(def!constant float-overflow-trap-bit (ash 1 3)) +(def!constant float-invalid-trap-bit (ash 1 4)) -(defconstant float-round-to-nearest 0) -(defconstant float-round-to-zero 1) -(defconstant float-round-to-positive 2) -(defconstant float-round-to-negative 3) +(def!constant float-round-to-nearest 0) +(def!constant float-round-to-zero 1) +(def!constant float-round-to-positive 2) +(def!constant float-round-to-negative 3) (defconstant-eqx float-rounding-mode (byte 2 30) #'equalp) ; RD (defconstant-eqx float-sticky-bits (byte 5 5) #'equalp) ; aexc @@ -102,7 +100,7 @@ ;;; bit (EFM) is "reserved", and should always be zero. However, for ;;; sparc-V8 and sparc-V9, it appears to work, causing denormals to ;;; be truncated to 0 silently. -(defconstant float-fast-bit (ash 1 22)) +(def!constant float-fast-bit (ash 1 22)) ); eval-when @@ -112,7 +110,7 @@ ;;; slots are required by architecture for a place to spill register windows. ;;; ;;; FIXME: Where is this used? -(defconstant number-stack-displacement +(def!constant number-stack-displacement (* 16 n-word-bytes)) @@ -121,36 +119,54 @@ ;;; Where to put the different spaces. Must match the C code! #!+linux (progn - (defconstant read-only-space-start #x10000000) - (defconstant read-only-space-end #x15000000) + (def!constant read-only-space-start #x10000000) + (def!constant read-only-space-end #x15000000) - (defconstant static-space-start #x28000000) - (defconstant static-space-end #x2c000000) + (def!constant static-space-start #x28000000) + (def!constant static-space-end #x2c000000) ;; From alpha/parms.lisp: ;; this is used in PURIFY as part of a sloppy check to see if a pointer ;; is in dynamic space. Chocolate brownie for the first person to fix it ;; -dan 20010502 - (defconstant dynamic-space-start #x30000000) - (defconstant dynamic-space-end #x38000000) + (def!constant dynamic-space-start #x30000000) + (def!constant dynamic-space-end #x38000000) - (defconstant dynamic-0-space-start #x30000000) - (defconstant dynamic-0-space-end #x38000000) + (def!constant dynamic-0-space-start #x30000000) + (def!constant dynamic-0-space-end #x38000000) - (defconstant dynamic-1-space-start #x40000000) - (defconstant dynamic-1-space-end #x48000000) + (def!constant dynamic-1-space-start #x40000000) + (def!constant dynamic-1-space-end #x48000000) - (defconstant control-stack-start #x50000000) - (defconstant control-stack-end #x51000000) + (def!constant control-stack-start #x50000000) + (def!constant control-stack-end #x51000000) - (defconstant binding-stack-start #x60000000) - (defconstant binding-stack-end #x61000000)) + (def!constant binding-stack-start #x60000000) + (def!constant binding-stack-end #x61000000)) -#!+solaris ; maybe someday. +#!+sunos ; might as well start by trying the same numbers (progn - (defparameter target-read-only-space-start #x10000000) - (defparameter target-static-space-start #x28000000) - (defparameter target-dynamic-space-start #x40000000)) + (def!constant read-only-space-start #x10000000) + (def!constant read-only-space-end #x15000000) + + (def!constant static-space-start #x28000000) + (def!constant static-space-end #x2c000000) + + (def!constant dynamic-space-start #x30000000) + (def!constant dynamic-space-end #x38000000) + + (def!constant dynamic-0-space-start #x30000000) + (def!constant dynamic-0-space-end #x38000000) + + (def!constant dynamic-1-space-start #x40000000) + (def!constant dynamic-1-space-end #x48000000) + + (def!constant control-stack-start #x50000000) + (def!constant control-stack-end #x51000000) + + (def!constant binding-stack-start #x60000000) + (def!constant binding-stack-end #x61000000)) + ;;;; other random constants. @@ -224,13 +240,22 @@ ;;;; Assembler parameters: ;;; The number of bits per element in the assemblers code vector. -;;; (defparameter *assembly-unit-length* 8) ;;;; Pseudo-atomic trap number -;;; KLUDGE + +;;; KLUDGE: Linux on the SPARC doesn't seem to conform to any kind of +;;; standards at all. So we use an explicitly undefined trap, because +;;; that currently does the right thing. Expect this to break +;;; eventually (but with luck, at that point we'll be able to revert +;;; to the compliant trap number... +;;; +;;; KLUDGE: Maybe this should be called pseudo-atomic-magic-number, +;;; allowing other architectures (which don't necessarily use traps +;;; for pseudo-atomic) to propagate a magic number to C land via +;;; sbcl.h. #!-linux -(defconstant pseudo-atomic-trap 16) +(def!constant pseudo-atomic-trap #x10) #!+linux -(defconstant pseudo-atomic-trap #x40) +(def!constant pseudo-atomic-trap #x40)