X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fsparc%2Fparms.lisp;h=c0f3dbb4c1894f92942292652a213fdbd32e6b5d;hb=cc56ee05b7ef035da9116a2117280087f58c8e94;hp=7bee9416e23359ff945f305390532e60a6853db1;hpb=0d669e68a1ffbea42af6216f2ae8c7d7ca12ffb6;p=sbcl.git diff --git a/src/compiler/sparc/parms.lisp b/src/compiler/sparc/parms.lisp index 7bee941..c0f3dbb 100644 --- a/src/compiler/sparc/parms.lisp +++ b/src/compiler/sparc/parms.lisp @@ -12,86 +12,88 @@ ;;;; 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 +;;; the natural width of a machine word (as seen in e.g. register width, +;;; address space) +(def!constant n-machine-word-bits 32) + +(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 +104,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 +114,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 +123,41 @@ ;;; 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) - - (defconstant control-stack-start #x50000000) - (defconstant control-stack-end #x51000000) - - (defconstant binding-stack-start #x60000000) - (defconstant binding-stack-end #x61000000)) + (def!constant dynamic-1-space-start #x40000000) + (def!constant dynamic-1-space-end #x48000000)) #!+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) - - (defconstant control-stack-start #x50000000) - (defconstant control-stack-end #x51000000) - - (defconstant binding-stack-start #x60000000) - (defconstant binding-stack-end #x61000000)) + (def!constant dynamic-1-space-start #x40000000) + (def!constant dynamic-1-space-end #x48000000)) ;;;; other random constants. @@ -206,26 +196,29 @@ ;; 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 - maybe-gc + ;; functions that the C code needs to call + sub-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 + *binding-stack-start* + *control-stack-start* + *control-stack-end* + + ;; interrupt handling *free-interrupt-context-index* sb!unix::*interrupts-enabled* sb!unix::*interrupt-pending* @@ -235,7 +228,7 @@ '(length two-arg-+ two-arg-- two-arg-* two-arg-/ two-arg-< two-arg-> two-arg-= two-arg-<= two-arg->= two-arg-/= eql %negate - two-arg-and two-arg-ior two-arg-xor + two-arg-and two-arg-ior two-arg-xor two-arg-eqv two-arg-gcd two-arg-lcm )) @@ -258,6 +251,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)