X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fppc%2Fparms.lisp;h=9d0a4a19ec3ec1e66a0dfcf06ad0adad02b23835;hb=8731c1a7c1a585d190151fa881050fb5e14c0616;hp=a8246fcc66c6cd64914ca950ac47f90796947a98;hpb=cab2c71bb1bb8a575d9eebdae335e731daa64183;p=sbcl.git

diff --git a/src/compiler/ppc/parms.lisp b/src/compiler/ppc/parms.lisp
index a8246fc..9d0a4a1 100644
--- a/src/compiler/ppc/parms.lisp
+++ b/src/compiler/ppc/parms.lisp
@@ -5,61 +5,61 @@
 
 (in-package "SB!VM")
 
-(defconstant n-word-bits 32
+(def!constant n-word-bits 32
   "Number of bits per word where a word holds one lisp descriptor.")
 
-(defconstant n-byte-bits 8
+(def!constant n-byte-bits 8
   "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)))
   "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)
   "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))
 
 
-(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 0) #'equalp)	  ; RD 
 (defconstant-eqx float-sticky-bits (byte 10 19) #'equalp)
 (defconstant-eqx float-traps-byte (byte 6 3) #'equalp)
 (defconstant-eqx float-exceptions-byte (byte 5 0) #'equalp)	  ; cexc
 
-(defconstant float-fast-bit 2)		; Non-IEEE mode
+(def!constant float-fast-bit 2)		; Non-IEEE mode
 
 
 ;;; NUMBER-STACK-DISPLACEMENT
@@ -68,7 +68,7 @@
 ;;; slots are required by architecture, mostly (?) to make C backtrace
 ;;; work.
 ;;; 
-(defconstant number-stack-displacement
+(def!constant number-stack-displacement
   (* 2 sb!vm:n-word-bytes))
 
 
@@ -77,29 +77,29 @@
 ;;; Where to put the different spaces.
 ;;; 
 
-(defconstant read-only-space-start #x01000000)
-(defconstant read-only-space-end   #x04ff8000)
+(def!constant read-only-space-start #x01000000)
+(def!constant read-only-space-end   #x04ff8000)
 
-(defconstant binding-stack-start   #x06000000)
-(defconstant binding-stack-end     #x06ff0000)
+(def!constant binding-stack-start   #x06000000)
+(def!constant binding-stack-end     #x06ff0000)
 
-(defconstant control-stack-start   #x07000000)
-(defconstant control-stack-end     #x07ff0000)
+(def!constant control-stack-start   #x07000000)
+(def!constant control-stack-end     #x07ff0000)
 
-(defconstant static-space-start    #x08000000)
-(defconstant static-space-end      #x097fff00)
+(def!constant static-space-start    #x08000000)
+(def!constant static-space-end      #x097fff00)
 
 ;;; FIXME: this is a gross violation of OAOO, done purely to support
 ;;; the #define of DYNAMIC_SPACE_SIZE in validate.c -- CSR, 2002-02-25
 ;;; (these numbers should match dynamic-0-*)
-(defconstant dynamic-space-start   #x40000000)
-(defconstant dynamic-space-end     #x47fff000)
+(def!constant dynamic-space-start   #x40000000)
+(def!constant dynamic-space-end     #x47fff000)
 
 ;;; nothing _seems_ to be using these addresses 
-(defconstant dynamic-0-space-start #x40000000)
-(defconstant dynamic-0-space-end   #x47fff000)
-(defconstant dynamic-1-space-start #x48000000)
-(defconstant dynamic-1-space-end   #x4ffff000)
+(def!constant dynamic-0-space-start #x40000000)
+(def!constant dynamic-0-space-end   #x47fff000)
+(def!constant dynamic-1-space-start #x48000000)
+(def!constant dynamic-1-space-end   #x4ffff000)