0.6.12.64:

	removed duplicate DEFKNOWNs for other compiler/x86/system.lisp
		stuff following the same approach as in 0.6.12.63
	removed other duplicate DEFKNOWNs by simple deletion
	tweaked DEF!MACRO DEFKNOWN so that it now handles duplicate
		DEFKNOWNs with CERROR instead of WARN

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 530aa5a..4f4f813 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -1331,23 +1331,3 @@
   ())
 (defknown %setnth (index list t) t (unsafe))
 (defknown %set-fill-pointer (vector index) index (unsafe))
-\f
-;;;; internal type predicates
-
-;;; Simple TYPEP uses that don't have any standard predicate are
-;;; translated into non-standard unary predicates.
-(defknown (fixnump bignump ratiop short-float-p single-float-p double-float-p
-          long-float-p base-char-p %standard-char-p %instancep
-          array-header-p)
-  (t) boolean (movable foldable flushable))
-
-;;; REMOVEME
-#|
-\f
-;;;; miscellaneous "sub-primitives"
-
-(defknown %sp-string-compare
-  (simple-string index index simple-string index index)
-  (or index null)
-  (foldable flushable))
-|#
\ No newline at end of file

diff --git a/src/compiler/generic/objdef.lisp b/src/compiler/generic/objdef.lisp
index 9320639..61cfaab 100644 (file)
--- a/src/compiler/generic/objdef.lisp
+++ b/src/compiler/generic/objdef.lisp
@@ -139,7 +139,24 @@
 (define-primitive-object (function :type function
                                   :lowtag function-pointer-type
                                   :header function-header-type)
-  #!-gengc (self :ref-trans %function-self :set-trans (setf %function-self))
+  #!-(or gengc x86) (self :ref-trans %function-self
+                         :set-trans (setf %function-self))
+  #!+x86 (self
+         ;; KLUDGE: There's no :SET-KNOWN, :SET-TRANS, :REF-KNOWN, or
+         ;; :REF-TRANS here in this case. Instead, there's separate
+         ;; DEFKNOWN/DEFINE-VOP/DEFTRANSFORM stuff in
+         ;; compiler/x86/system.lisp to define and declare them by
+         ;; hand. I don't know why this is, but that's (basically)
+         ;; the way it was done in CMU CL, and it works. (It's not
+         ;; exactly the same way it was done in CMU CL in that CMU
+         ;; CL's allows duplicate DEFKNOWNs, blithely overwriting any
+         ;; previous data associated with the previous DEFKNOWN, and
+         ;; that property was used to mask the definitions here. In
+         ;; SBCL as of 0.6.12.64 that's not allowed -- too confusing!
+         ;; -- so we have to explicitly suppress the DEFKNOWNish
+         ;; stuff here in order to allow this old hack to work in the
+         ;; new world. -- WHN 2001-08-82
+         )
   #!+gengc (entry-point :c-type "char *")
   (next :type (or function null)
        :ref-known (flushable)

diff --git a/src/compiler/knownfun.lisp b/src/compiler/knownfun.lisp
index 8a1d3fc..84799f1 100644 (file)
--- a/src/compiler/knownfun.lisp
+++ b/src/compiler/knownfun.lisp
@@ -173,19 +173,18 @@
     (dolist (name names)
       (let ((old-function-info (info :function :info name)))
        (when old-function-info
-         ;; This is an error because it's generally a bad thing to blow
-         ;; away all the old optimization stuff. It's also a potential
-         ;; source of sneaky bugs:
+         ;; This is handled as an error because it's generally a bad
+         ;; thing to blow away all the old optimization stuff. It's
+         ;; also a potential source of sneaky bugs:
          ;;    DEFKNOWN FOO
          ;;    DEFTRANSFORM FOO
          ;;    DEFKNOWN FOO ; possibly hidden inside some macroexpansion
          ;;    ; Now the DEFTRANSFORM doesn't exist in the target Lisp.
          ;; However, it's continuable because it might be useful to do
          ;; it when testing new optimization stuff interactively.
-         #+nil (cerror "Go ahead, overwrite it."
-                       "overwriting old FUNCTION-INFO for ~S" name)
-         (warn "~@<overwriting old FUNCTION-INFO ~2I~_~S ~I~_for ~S~:>"
-               old-function-info name)))
+         (cerror "Go ahead, overwrite it."
+                 "~@<overwriting old FUNCTION-INFO ~2I~_~S ~I~_for ~S~:>"
+                 old-function-info name)))
       (setf (info :function :type name target-env) ctype)
       (setf (info :function :where-from name target-env) :declared)
       (setf (info :function :kind name target-env) :function)

diff --git a/src/compiler/x86/system.lisp b/src/compiler/x86/system.lisp
index 95de87f..86cc500 100644 (file)
--- a/src/compiler/x86/system.lisp
+++ b/src/compiler/x86/system.lisp
@@ -214,9 +214,6 @@
                   :disp (- function-pointer-type other-pointer-type)))
     (inst add func code)))
 
-;;; REMOVEME
-(defknown %function-self (function) function (flushable))
-
 (define-vop (%function-self)
   (:policy :fast-safe)
   (:translate %function-self)
@@ -238,9 +235,6 @@
 (def-source-transform %funcallable-instance-function (fin)
   `(%function-self ,fin))
 
-;;; REMOVEME
-(defknown (setf %function-self) (function function) function  (unsafe))
-
 (define-vop (%set-function-self)
   (:policy :fast-safe)
   (:translate (setf %function-self))

diff --git a/version.lisp-expr b/version.lisp-expr
index 2426550..b8bcd1b 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -16,4 +16,4 @@
 ;;; four numeric fields, is used for versions which aren't released
 ;;; but correspond only to CVS tags or snapshots.
 
-"0.6.12.63"
+"0.6.12.64"