X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fgeneric%2Fobjdef.lisp;h=83fa84ff7f583cfee7cc1b061d8238fb32c3d92f;hb=f7faed97898dd0e94a18b0d1fca03aaa0fe24ab0;hp=4082bd17743e6449bb6b67715dcdae05b4f85b38;hpb=5759fa78f2289c7e891aaded2a54e069b8bdac01;p=sbcl.git diff --git a/src/compiler/generic/objdef.lisp b/src/compiler/generic/objdef.lisp index 4082bd1..83fa84f 100644 --- a/src/compiler/generic/objdef.lisp +++ b/src/compiler/generic/objdef.lisp @@ -14,9 +14,6 @@ ;;;; KLUDGE: The primitive objects here may look like self-contained ;;;; definitions, but in general they're not. In particular, if you ;;;; try to add a slot to them, beware of the following: -;;;; * (mysterious crashes which occur after changing the length -;;;; of SIMPLE-FUN, just adding a new slot not even doing anything -;;;; with it, still dunno why) ;;;; * The GC scavenging code (and for all I know other GC code too) ;;;; is not automatically generated from these layouts, but instead ;;;; was hand-written to correspond to them. The offsets are @@ -38,7 +35,8 @@ ;;;; the primitive objects themselves -(define-primitive-object (cons :lowtag list-pointer-lowtag +(define-primitive-object (cons :type cons + :lowtag list-pointer-lowtag :alloc-trans cons) (car :ref-trans car :set-trans sb!c::%rplaca :init :arg :cas-trans %compare-and-swap-car) @@ -126,11 +124,16 @@ :ref-known (flushable foldable) :set-trans (setf %array-displacement) :set-known (unsafe)) - (displaced-p :type (member t nil) + (displaced-p :type t :ref-trans %array-displaced-p :ref-known (flushable foldable) :set-trans (setf %array-displaced-p) :set-known (unsafe)) + (displaced-from :type list + :ref-trans %array-displaced-from + :ref-known (flushable) + :set-trans (setf %array-displaced-from) + :set-known (unsafe)) (dimensions :rest-p t)) (define-primitive-object (vector :type vector @@ -209,11 +212,13 @@ :ref-trans %simple-fun-type :set-known (unsafe) :set-trans (setf %simple-fun-type)) - (xrefs :init :null - :ref-trans %simple-fun-xrefs - :ref-known (flushable) - :set-trans (setf %simple-fun-xrefs) - :set-known ()) + ;; NIL for empty, STRING for a docstring, SIMPLE-VECTOR for XREFS, and (CONS + ;; STRING SIMPLE-VECTOR) for both. + (info :init :null + :ref-trans %simple-fun-info + :ref-known (flushable) + :set-trans (setf %simple-fun-info) + :set-known (unsafe)) ;; the SB!C::DEBUG-FUN object corresponding to this object, or NIL for none #+nil ; FIXME: doesn't work (gotcha, lowly maintenoid!) See notes on bug 137. (debug-fun :ref-known (flushable) @@ -241,6 +246,8 @@ (define-primitive-object (value-cell :lowtag other-pointer-lowtag :widetag value-cell-header-widetag + ;; FIXME: We also have an explicit VOP + ;; for this. Is this needed as well? :alloc-trans make-value-cell) (value :set-trans value-cell-set :set-known (unsafe) @@ -293,8 +300,7 @@ #!+win32 next-seh-frame #!+win32 seh-frame-handler tag - (previous-catch :c-type #!-alpha "struct catch_block *" #!+alpha "u32") - size) + (previous-catch :c-type #!-alpha "struct catch_block *" #!+alpha "u32")) ;;; (For an explanation of this, see the comments at the definition of ;;; KLUDGE-NONDETERMINISTIC-CATCH-BLOCK-SIZE.) @@ -304,7 +310,8 @@ (define-primitive-object (symbol :lowtag other-pointer-lowtag :widetag symbol-header-widetag - :alloc-trans %make-symbol) + :alloc-trans %make-symbol + :type symbol) ;; Beware when changing this definition. NIL-the-symbol is defined ;; using this layout, and NIL-the-end-of-list-marker is the cons @@ -316,7 +323,9 @@ ;; first data slot, and if you subtract 7 you get a symbol header. ;; also the CAR of NIL-as-end-of-list - (value :init :unbound :ref-known (flushable) :ref-trans symbol-global-value) + (value :init :unbound + :set-trans %set-symbol-global-value + :set-known (unsafe)) ;; also the CDR of NIL-as-end-of-list. Its reffer needs special ;; care for this reason, as hash values must be fixnums. (hash :set-trans %set-symbol-hash) @@ -335,54 +344,53 @@ (define-primitive-object (complex-single-float :lowtag other-pointer-lowtag :widetag complex-single-float-widetag) + #!+x86-64 + (data :c-type "struct { float data[2]; } ") + #!-x86-64 (real :c-type "float") + #!-x86-64 (imag :c-type "float")) (define-primitive-object (complex-double-float :lowtag other-pointer-lowtag :widetag complex-double-float-widetag) - #!-x86-64 (filler) + (filler) (real :c-type "double" :length #!-x86-64 2 #!+x86-64 1) (imag :c-type "double" :length #!-x86-64 2 #!+x86-64 1)) -#!+(and sb-lutex sb-thread) -(define-primitive-object (lutex - :lowtag other-pointer-lowtag - :widetag lutex-widetag - :alloc-trans %make-lutex) - (gen :c-type "long" :length 1) - (live :c-type "long" :length 1) - (next :c-type "struct lutex *" :length 1) - (prev :c-type "struct lutex *" :length 1) - (mutex :c-type "pthread_mutex_t *" - :length 1) - (mutexattr :c-type "pthread_mutexattr_t *" - :length 1) - (condition-variable :c-type "pthread_cond_t *" - :length 1)) - ;;; this isn't actually a lisp object at all, it's a c structure that lives ;;; in c-land. However, we need sight of so many parts of it from Lisp that ;;; it makes sense to define it here anyway, so that the GENESIS machinery ;;; can take care of maintaining Lisp and C versions. -;;; Hence the even-fixnum lowtag just so we don't get odd(sic) numbers -;;; added to the slot offsets -(define-primitive-object (thread :lowtag even-fixnum-lowtag) +(define-primitive-object (thread) ;; no_tls_value_marker is borrowed very briefly at thread startup to ;; pass the address of initial-function into new_thread_trampoline. ;; tls[0] = NO_TLS_VALUE_MARKER_WIDETAG because a the tls index slot ;; of a symbol is initialized to zero (no-tls-value-marker) - (os-thread :c-type "volatile os_thread_t") + (os-thread :c-type "os_thread_t") ;; This is the original address at which the memory was allocated, ;; which may have different alignment then what we prefer to use. - ;; Kept here so that when the thread dies we can releast the whole + ;; Kept here so that when the thread dies we can release the whole ;; memory we reserved. (os-address :c-type "void *" :length #!+alpha 2 #!-alpha 1) + #!+sb-thread + (os-attr :c-type "pthread_attr_t *" :length #!+alpha 2 #!-alpha 1) + #!+sb-thread + (state-sem :c-type "os_sem_t *" :length #!+alpha 2 #!-alpha 1) + #!+sb-thread + (state-not-running-sem :c-type "os_sem_t *" :length #!+alpha 2 #!-alpha 1) + #!+sb-thread + (state-not-running-waitcount :c-type "int" :length 1) + #!+sb-thread + (state-not-stopped-sem :c-type "os_sem_t *" :length #!+alpha 2 #!-alpha 1) + #!+sb-thread + (state-not-stopped-waitcount :c-type "int" :length 1) (binding-stack-start :c-type "lispobj *" :length #!+alpha 2 #!-alpha 1) (binding-stack-pointer :c-type "lispobj *" :length #!+alpha 2 #!-alpha 1) (control-stack-start :c-type "lispobj *" :length #!+alpha 2 #!-alpha 1) (control-stack-end :c-type "lispobj *" :length #!+alpha 2 #!-alpha 1) + (control-stack-guard-page-protected) (alien-stack-start :c-type "lispobj *" :length #!+alpha 2 #!-alpha 1) (alien-stack-pointer :c-type "lispobj *" :length #!+alpha 2 #!-alpha 1) #!+gencgc (alloc-region :c-type "struct alloc_region" :length 5) @@ -390,10 +398,30 @@ (prev :c-type "struct thread *" :length #!+alpha 2 #!-alpha 1) (next :c-type "struct thread *" :length #!+alpha 2 #!-alpha 1) ;; starting, running, suspended, dead - (state :c-type "volatile lispobj") + (state :c-type "lispobj") (tls-cookie) ; on x86, the LDT index - #!+(or x86 x86-64) (pseudo-atomic-bits) + #!+(or x86 x86-64 sb-thread) (pseudo-atomic-bits) (interrupt-data :c-type "struct interrupt_data *" :length #!+alpha 2 #!-alpha 1) (stepping) + ;; For various reasons related to pseudo-atomic and interrupt + ;; handling, we need to know if the machine context is in Lisp code + ;; or not. On non-threaded targets, this is a global variable in + ;; the runtime, but it's clearly a per-thread value. + #!+sb-thread + (foreign-function-call-active :c-type "boolean") + ;; Same as above for the location of the current control stack frame. + #!+(and sb-thread (not (or x86 x86-64))) + (control-frame-pointer :c-type "lispobj *") + ;; Same as above for the location of the current control stack + ;; pointer. This is also used on threaded x86oids to allow LDB to + ;; print an approximation of the CSP as needed. + #!+(and sb-thread) + (control-stack-pointer :c-type "lispobj *") + ;; KLUDGE: On alpha, until STEPPING we have been lucky and the 32 + ;; bit slots came in pairs. However the C compiler will align + ;; interrupt_contexts on a double word boundary. This logic should + ;; be handled by DEFINE-PRIMITIVE-OBJECT. + #!+alpha + (padding) (interrupt-contexts :c-type "os_context_t *" :rest-p t))