X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fgeneric%2Fobjdef.lisp;h=15d86cc2417c2ab6f7662f630faf97cc3a05ca3d;hb=c9674c84337b4664d6554a51e7ff11a5433102bc;hp=7ab3fc8374ad4a158dc95b9c6ff80f31b4c3491a;hpb=c580293e8550414004697173f7e2c2b6bdf81070;p=sbcl.git

diff --git a/src/compiler/generic/objdef.lisp b/src/compiler/generic/objdef.lisp
index 7ab3fc8..15d86cc 100644
--- a/src/compiler/generic/objdef.lisp
+++ b/src/compiler/generic/objdef.lisp
@@ -207,6 +207,11 @@
         :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 ())
   ;; 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)
@@ -221,78 +226,15 @@
 (define-primitive-object (closure :lowtag fun-pointer-lowtag
                                   :widetag closure-header-widetag)
   (fun :init :arg :ref-trans %closure-fun)
-  ;; This SELF slot needs explanation.
-  ;;
-  ;; Ordinary closures did not need this slot before version 0.9.3.xx,
-  ;; as the closure object was already in some dedicated register --
-  ;; EAX/RAX on x86(-64), reg_LEXENV on register-rich platforms -- and
-  ;; consequently setting up the environment (from the INFO slot,
-  ;; below) was easy.
-  ;;
-  ;; However, it is not easy to support calling FUNCALLABLE-INSTANCEs
-  ;; in the same way; in a FUNCALLABLE-INSTANCE, there are
-  ;; conceptually two variable-length data areas: the closure
-  ;; environment, if any, and the slots of the instance.
-  ;;
-  ;; Until sbcl-0.9.3.xx, it was required that closures to be set as a
-  ;; FUNCALLABLE-INSTANCE-FUNCTION be defined using the magical
-  ;; keyword SB-KERNEL:INSTANCE-LAMBDA, rather than ordinary LAMBDA;
-  ;; this caused an extra indirection to be compiled into the closure
-  ;; code to load the closure from the FUNCALLABLE-INSTANCE-LEXENV
-  ;; slot before setting up the environment for the function body.
-  ;; Failure to obey this protocol yielded confusing error messages as
-  ;; either INSTANCE-LAMBDAs tried to dereference environments that
-  ;; weren't there, or ordinary LAMBDAs got hold of the LAYOUT and
-  ;; LEXENV slots of a FUNCALLABLE-INSTANCE.
-  ;;
-  ;; By adding this SELF slot, which is at the same offset in a
-  ;; regular CLOSURE as the LEXENV slot is in a FUNCALLABLE-INSTANCE,
-  ;; we enable the extra indirection (VOP FUNCALLABLE-INSTANCE-LEXENV,
-  ;; in src/compiler/ir2tran.lisp) to be compiled unconditionally
-  ;; (provided that we set this slot to the closure object itself).
-  ;; Relative to the code before, this adds a word to the space
-  ;; requirements of a closure, and one instruction (a memory fetch)
-  ;; to the body of a closure function.
-  ;;
-  ;; There are potentially other implementation strategies which would
-  ;; remove the need for this extra indirection in regular closures,
-  ;; such as setting up a trampoline for funcallable instances (though
-  ;; it was not clear to me that there are enough registers free in
-  ;; the x86 backend to permit this).  This indirection should not be
-  ;; too disastrous, given that for regular closures the fetch is from
-  ;; memory which is known to be active.
-  ;;
-  ;; CSR, 2005-08-05
-  (self) ; KLUDGE (see above comment)
   (info :rest-p t))
 
 (define-primitive-object (funcallable-instance
                           :lowtag fun-pointer-lowtag
                           :widetag funcallable-instance-header-widetag
                           :alloc-trans %make-funcallable-instance)
-  #!-(or x86 x86-64)
-  (fun
-   :ref-known (flushable) :ref-trans %funcallable-instance-fun
-   :set-known (unsafe) :set-trans (setf %funcallable-instance-fun))
-  #!+(or x86 x86-64)
-  (fun
-   :ref-known (flushable) :ref-trans %funcallable-instance-fun
-   ;; KLUDGE: There's no :SET-KNOWN or :SET-TRANS in this case.
-   ;; Instead, later in compiler/x86/system.lisp there's a separate
-   ;; DEFKNOWN for (SETF %FUNCALLABLE-INSTANCE-FUN), and a weird
-   ;; unexplained DEFTRANSFORM from (SETF %SIMPLE-FUN-INSTANCE-FUN)
-   ;; into (SETF %SIMPLE-FUN-SELF). The #!+X86 wrapped around this case
-   ;; is a literal translation of the old CMU CL implementation into
-   ;; the new world of sbcl-0.6.12.63, where multiple DEFKNOWNs for
-   ;; the same operator cause an error (instead of silently deleting
-   ;; all information associated with the old DEFKNOWN, as before).
-   ;; It's definitely not very clean, with too many #!+ conditionals and
-   ;; too little documentation, but I have more urgent things to
-   ;; clean up right now, so I've just left it as a literal
-   ;; translation without trying to fix it. -- WHN 2001-08-02
-   )
-  (lexenv :ref-known (flushable) :ref-trans %funcallable-instance-lexenv
-          :set-known (unsafe) :set-trans (setf %funcallable-instance-lexenv))
+  (trampoline :init :funcallable-instance-tramp)
+  (function :ref-known (flushable) :ref-trans %funcallable-instance-function
+            :set-known (unsafe) :set-trans (setf %funcallable-instance-function))
   (info :rest-p t))
 
 (define-primitive-object (value-cell :lowtag other-pointer-lowtag
@@ -337,13 +279,17 @@
   (current-uwp :c-type #!-alpha "struct unwind_block *" #!+alpha "u32")
   (current-cont :c-type #!-alpha "lispobj *" #!+alpha "u32")
   #!-(or x86 x86-64) current-code
-  entry-pc)
+  entry-pc
+  #!+win32 next-seh-frame
+  #!+win32 seh-frame-handler)
 
 (define-primitive-object (catch-block)
   (current-uwp :c-type #!-alpha "struct unwind_block *" #!+alpha "u32")
   (current-cont :c-type #!-alpha "lispobj *" #!+alpha "u32")
   #!-(or x86 x86-64) current-code
   entry-pc
+  #!+win32 next-seh-frame
+  #!+win32 seh-frame-handler
   tag
   (previous-catch :c-type #!-alpha "struct catch_block *" #!+alpha "u32")
   size)
@@ -356,7 +302,7 @@
 
 (define-primitive-object (symbol :lowtag other-pointer-lowtag
                                  :widetag symbol-header-widetag
-                                 :alloc-trans make-symbol)
+                                 :alloc-trans %make-symbol)
 
   ;; Beware when changing this definition.  NIL-the-symbol is defined
   ;; using this layout, and NIL-the-end-of-list-marker is the cons
@@ -395,6 +341,22 @@
   (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
@@ -421,8 +383,8 @@
   ;; starting, running, suspended, dead
   (state :c-type "volatile lispobj")
   (tls-cookie)                          ;  on x86, the LDT index
-  #!+(or x86 x86-64) (pseudo-atomic-atomic)
-  #!+(or x86 x86-64) (pseudo-atomic-interrupted)
+  #!+(or x86 x86-64) (pseudo-atomic-bits)
   (interrupt-data :c-type "struct interrupt_data *"
                   :length #!+alpha 2 #!-alpha 1)
+  (stepping)
   (interrupt-contexts :c-type "os_context_t *" :rest-p t))