X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Falpha%2Fparms.lisp;h=267f272edce27bde145522ddad48155cc219d717;hb=1e4629723d19f96d752235ffde34fe58431431ae;hp=a73dc080a9a6c83c6d1f44920cc7a5bb07640c10;hpb=f43f136f9b3ff6cae501e850fa67b2183317e212;p=sbcl.git diff --git a/src/compiler/alpha/parms.lisp b/src/compiler/alpha/parms.lisp index a73dc08..267f272 100644 --- a/src/compiler/alpha/parms.lisp +++ b/src/compiler/alpha/parms.lisp @@ -11,71 +11,98 @@ (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.") -(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)) -(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)) -;; Values in 17f code seem to be same as HPPA. These values are from -;; DEC Assembly Language Programmers guide. The active bits are -;; actually in (byte 12 52) of the fpcr. (byte 6 52) contain the -;; exception flags. Bit 63 is the bitwise logor of all exceptions. -;; The enable and exception bytes are in a software control word -;; manipulated via OS functions and the bits in the SCP match those -;; defs. This mapping follows -(defconstant float-inexact-trap-bit (ash 1 4)) ; rw -(defconstant float-underflow-trap-bit (ash 1 3)) ; rw -(defconstant float-overflow-trap-bit (ash 1 2)) ; ro -(defconstant float-divide-by-zero-trap-bit (ash 1 1)) ; ro -(defconstant float-invalid-trap-bit (ash 1 0)) ; ro - -(defconstant float-round-to-zero 0) -(defconstant float-round-to-negative 1) -(defconstant float-round-to-nearest 2) -(defconstant float-round-to-positive 3) - -;; These aren't quite correct yet. Work in progress. -(defconstant-eqx float-rounding-mode (byte 2 58) #'equalp) ; hardware fpcr -(defconstant-eqx float-exceptions-byte (byte 6 52) #'equalp) ; hardware fpcr -(defconstant-eqx float-sticky-bits (byte 6 17) #'equalp) ; software (clear only) -(defconstant-eqx float-traps-byte (byte 6 1) #'equalp) ; software fp control word -(defconstant float-condition-bit (ash 1 63)) ; summary - not used?? XXX -(defconstant float-fast-bit 0) +;;; These values are originally from the DEC Assembly Language +;;; Programmers guide. Where possible we read/write the software +;;; fp_control word, which apparently is necessary for the OS FPU +;;; completion (OS handler which fixes up non-IEEE answers that the +;;; hardware occasionally gives us) to work properly. The rounding +;;; mode, however, can't be set that way, so we have to deal with that +;;; directly. (FIXME: we actually don't suport setting the rounding mode +;;; at the moment anyway) + +;;; Short guide to floating point trap terminology: an "exception" is +;;; cheap and can happen at almost any time. An exception will only +;;; generate a trap if that trap is enabled, otherwise a default value +;;; will be substituted. A "trap" will end up somewhere in the +;;; kernel, which may play by its own rules, (on Alpha it allegedly +;;; actually fixes up some non-IEEE compliant results to get the +;;; _right_ answer) but if something is really wrong will eventually +;;; signal SIGFPE and let us sort it out. + +;;; Old comment follows: The active bits are actually in (byte 12 52) +;;; of the fpcr. (byte 6 52) contain the exception flags. Bit 63 is the +;;; bitwise logor of all exceptions. The enable and exception bytes +;;; are in a software control word manipulated via OS functions and the +;;; bits in the SCP match those defs. This mapping follows +;;; + +;;; trap enables are set in software (fp_control) +(def!constant float-inexact-trap-bit (ash 1 4)) ; rw +(def!constant float-underflow-trap-bit (ash 1 3)) ; rw +(def!constant float-overflow-trap-bit (ash 1 2)) ; ro +(def!constant float-divide-by-zero-trap-bit (ash 1 1)) ; ro +(def!constant float-invalid-trap-bit (ash 1 0)) ; ro +(defconstant-eqx float-traps-byte (byte 6 1) #'equalp) + +;;; exceptions are also read/written in software (by syscalls, no less). +;;; This is kind of dumb, but has to be done +(defconstant-eqx float-sticky-bits (byte 6 17) #'equalp) ; fp_control + +;;; (We don't actually _have_ "current exceptions" on Alpha; the +;;; hardware only ever sets bits. So, set this the same as accrued +;;; exceptions) +(defconstant-eqx float-exceptions-byte (byte 6 17) #'equalp) + +;;; Rounding modes can only be set by frobbing the hardware fpcr directly +(def!constant float-round-to-zero 0) +(def!constant float-round-to-negative 1) +(def!constant float-round-to-nearest 2) +(def!constant float-round-to-positive 3) +(defconstant-eqx float-rounding-mode (byte 2 58) #'equalp) + +;;; Miscellaneous stuff - I think it's far to say that you deserve +;;; what you get if you ask for fast mode. +(def!constant float-fast-bit 0) ); eval-when @@ -88,45 +115,45 @@ #!+linux (progn - (defconstant read-only-space-start #x20000000) - (defconstant read-only-space-end #x24000000) + (def!constant read-only-space-start #x20000000) + (def!constant read-only-space-end #x24000000)) - (defconstant static-space-start #x28000000) - (defconstant static-space-end #x2c000000) +#!+osf1 +(progn + (defconstant read-only-space-start #x10000000) + (defconstant read-only-space-end #x25000000)) - ;; 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) - (defconstant dynamic-0-space-start #x30000000) - (defconstant dynamic-0-space-end #x38000000) - - (defconstant dynamic-1-space-start #x40000000) - (defconstant dynamic-1-space-end #x48000000) +(def!constant static-space-start #x28000000) +(def!constant static-space-end #x2c000000) - (defconstant control-stack-start #x50000000) - (defconstant control-stack-end #x51000000) +;; 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 +(def!constant dynamic-space-start #x30000000) +(def!constant dynamic-space-end #x3fff0000) - (defconstant binding-stack-start #x70000000) - (defconstant binding-stack-end #x71000000)) +(def!constant dynamic-0-space-start #x30000000) +(def!constant dynamic-0-space-end #x3fff0000) -#!+osf1 ;as if -(progn - (defparameter read-only-space-start #x10000000) - (defparameter static-space-start #x28000000) - (defparameter dynamic-space-start #x30000000)) +(def!constant dynamic-1-space-start #x40000000) +(def!constant dynamic-1-space-end #x4fff0000) + +(def!constant control-stack-start #x50000000) +(def!constant control-stack-end #x51000000) + +(def!constant binding-stack-start #x70000000) +(def!constant binding-stack-end #x71000000) ;;; FIXME nothing refers to either of these in alpha or x86 cmucl ;;; backend, so they could probably be removed. ;; The space-register holding the lisp heap. -(defconstant lisp-heap-space 4) +(def!constant lisp-heap-space 4) ;; The space-register holding the C text segment. -(defconstant c-text-space 4) +(def!constant c-text-space 4) ;;; the X86 port defines *nil-value* as (+ *target-static-space-start* #xB) ;;; here, but it seems to be the only port that needs to know the @@ -146,8 +173,8 @@ (defenum (:prefix trace-table-) normal call-site - function-prologue - function-epilogue) + fun-prologue + fun-epilogue) ;;;; static symbols @@ -182,7 +209,6 @@ ;; things needed for non-local exit *current-catch-block* *current-unwind-protect-block* - *eval-stack-top* ;; interrupt handling *free-interrupt-context-index*