X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fsparc%2Fparms.lisp;h=f66386a4f0c6866c8899cb545d67771b1a5b9f47;hb=4ff8421d6f4590024f82ea6f6851e25b4ca3df99;hp=7bee9416e23359ff945f305390532e60a6853db1;hpb=0d669e68a1ffbea42af6216f2ae8c7d7ca12ffb6;p=sbcl.git diff --git a/src/compiler/sparc/parms.lisp b/src/compiler/sparc/parms.lisp index 7bee941..f66386a 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,53 +119,53 @@ ;;; 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)) #!+sunos ; might as well start by trying the same numbers (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) - (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)) ;;;; other random constants. @@ -206,26 +204,25 @@ ;; The C startup code must fill these in. *posix-argv* - ;;lisp::lisp-environment-list - ;;lisp::lisp-command-line-list sb!impl::*!initial-fdefn-objects* - ;; Functions that the C code needs to call + ;; functions that the C code needs to call maybe-gc sb!kernel::internal-error + sb!kernel::control-stack-exhausted-error sb!di::handle-breakpoint sb!di::handle-fun-end-breakpoint - ;; Free Pointers. + ;; free pointers *read-only-space-free-pointer* *static-space-free-pointer* *initial-dynamic-space-free-pointer* - ;; Things needed for non-local-exit. + ;; things needed for non-local exit *current-catch-block* *current-unwind-protect-block* - ;; Interrupt Handling + ;; interrupt handling *free-interrupt-context-index* sb!unix::*interrupts-enabled* sb!unix::*interrupt-pending* @@ -258,6 +255,6 @@ ;;; for pseudo-atomic) to propagate a magic number to C land via ;;; sbcl.h. #!-linux -(defconstant pseudo-atomic-trap #x10) +(def!constant pseudo-atomic-trap #x10) #!+linux -(defconstant pseudo-atomic-trap #x40) +(def!constant pseudo-atomic-trap #x40)