X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fppc%2Fparms.lisp;h=4e05dd7edb8314705c4c418c74c32e1e39937a72;hb=4ed3f0d08c3a57a6762018d9622f253ab9d0f2b6;hp=a8246fcc66c6cd64914ca950ac47f90796947a98;hpb=cab2c71bb1bb8a575d9eebdae335e731daa64183;p=sbcl.git diff --git a/src/compiler/ppc/parms.lisp b/src/compiler/ppc/parms.lisp index a8246fc..4e05dd7 100644 --- a/src/compiler/ppc/parms.lisp +++ b/src/compiler/ppc/parms.lisp @@ -2,104 +2,122 @@ ;;;; attributes for the PPC. This file is separate from other stuff so ;;;; that it can be compiled and loaded earlier. +;;;; This software is part of the SBCL system. See the README file for +;;;; more information. +;;;; +;;;; This software is derived from the CMU CL system, which was +;;;; written at Carnegie Mellon University and released into the +;;;; public domain. The software is in the public domain and is +;;;; provided with absolutely no warranty. See the COPYING and CREDITS +;;;; files for more information. (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 +;;; 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 "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)) - -(defconstant float-round-to-nearest 0) -(defconstant float-round-to-zero 1) -(defconstant float-round-to-positive 2) -(defconstant 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 +(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)) + +(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 +;;; FIXME I: Beware, all ye who trespass here. Despite its name, +;;; FLOAT-STICKY-BITS is not the byte specifier for sticky bits in the +;;; floating point control word. It is more like "accrued exceptions" +;;; where FLOAT-EXCEPTIONS-BYTE is "current exceptions". Consequently, +;;; on architectures where there is no "current exceptions" +;;; FLOAT-EXCEPTIONS-BYTE and FLOAT-STICKY-BITS had better be the +;;; same. +;;; +;;; FIXME II: So, I've now documented this in comments in the PowerPC +;;; tree. This may not make it easy to find for when new architectures +;;; get backends written... +;;; +;;; CSR, 2002-06-11 +(defconstant-eqx float-sticky-bits (byte 5 25) #'equalp) +(defconstant-eqx float-traps-byte (byte 5 3) #'equalp) +(defconstant-eqx float-exceptions-byte (byte 5 25) #'equalp) ; cexc -(defconstant float-fast-bit 2) ; Non-IEEE mode +(def!constant float-fast-bit 2) ; Non-IEEE mode ;;; NUMBER-STACK-DISPLACEMENT ;;; ;;; The number of bytes reserved above the number stack pointer. These ;;; slots are required by architecture, mostly (?) to make C backtrace -;;; work. +;;; work. This must be a power of 2 - see BYTES-REQUIRED-FOR-NUMBER-STACK. ;;; -(defconstant number-stack-displacement - (* 2 sb!vm:n-word-bytes)) - +(def!constant number-stack-displacement + (* #!-darwin 2 + #!+darwin 8 + n-word-bytes)) - ;;; Where to put the different spaces. -;;; - -(defconstant read-only-space-start #x01000000) -(defconstant read-only-space-end #x04ff8000) -(defconstant binding-stack-start #x06000000) -(defconstant binding-stack-end #x06ff0000) +(def!constant read-only-space-start #x01000000) +(def!constant read-only-space-end #x04ff8000) -(defconstant control-stack-start #x07000000) -(defconstant 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) @@ -143,31 +161,33 @@ ;; The C startup code must fill these in. *posix-argv* - sb!impl::*initial-fdefn-objects* - ;; Functions that the C code needs to call - ;; sb!impl::%initial-fun - sb!impl::maybe-gc + ;; functions that the C code needs to call + sb!impl::sub-gc sb!kernel::internal-error + sb!kernel::control-stack-exhausted-error sb!di::handle-breakpoint sb!impl::fdefinition-object - ;; 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* - *eval-stack-top* - ;; 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* - #|sb!kernel::*current-thread*|# + )) (defparameter *static-funs* @@ -187,6 +207,7 @@ sb!kernel:two-arg-and sb!kernel:two-arg-ior sb!kernel:two-arg-xor + sb!kernel:two-arg-eqv sb!kernel:two-arg-gcd sb!kernel:two-arg-lcm))