diff --git a/bootfiles/18e/boot15.lisp b/bootfiles/18e/boot15.lisp new file mode 100644 index 0000000000000000000000000000000000000000..09714f19088c7ca0f06541a79c08cf9e876ddb9d --- /dev/null +++ b/bootfiles/18e/boot15.lisp @@ -0,0 +1,21 @@ +;;; +;;; Bootstrap file for adding dynamic-extent rest args. +;;; + +(in-package :cl-user) +(use-package :fwrappers) + +;;; +;;; Prevent structure redefinition dialogs. +;;; +(define-fwrapper return-nil (&rest args) (call-next-function) nil) +(fwrap 'kernel::redefine-layout-warning #'return-nil) +(push :bootstrap-dynamic-extent *features*) + +;;; +;;; Make compiler-layouts known to the compiler, for the change +;;; in the struct C::LEAF, which gets a new slot. +;;; +(compile-file "target:compiler/node") + +;;; End of file. diff --git a/code/class.lisp b/code/class.lisp index 7ed91c9c31f79898687892a2a22bafd93c5b4280..b47a7313a99f583ffa13e498cd26e9305cb793ef 100644 --- a/code/class.lisp +++ b/code/class.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/class.lisp,v 1.56 2003/06/06 16:23:45 toy Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/class.lisp,v 1.57 2003/08/05 14:04:53 gerd Exp $") ;;; ;;; ********************************************************************** ;;; @@ -1171,6 +1171,7 @@ ((not *type-system-initialized*) (setf (layout-class old) class) old) + #-bootstrap-dynamic-extent ((redefine-layout-warning old "current" res "compile time") (restart-case (error "Loading a reference to class ~S when the compile~ diff --git a/compiler/eval-comp.lisp b/compiler/eval-comp.lisp index d144c8c23c29c71206036df80f3a20374efa6e5b..824e92ea623cfa715919a8cf83da36d4ede9578b 100644 --- a/compiler/eval-comp.lisp +++ b/compiler/eval-comp.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/eval-comp.lisp,v 1.33 2003/01/21 16:51:09 toy Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/eval-comp.lisp,v 1.34 2003/08/05 14:04:52 gerd Exp $") ;;; ;;; ********************************************************************** ;;; @@ -285,8 +285,8 @@ (defun %more-arg (args index) (nth index args)) -(defun %listify-rest-args (ptr count) - (declare (ignore count)) +(defun %listify-rest-args (ptr count #+x86 dynamic-extent) + (declare (ignore count #+x86 dynamic-extent)) ptr) (defun %more-arg-values (args start count) diff --git a/compiler/fndb.lisp b/compiler/fndb.lisp index 408e56f20fa81ccb26453bfe45ba70ef80759721..338c8580e0a3f0b7dd2bfd9a745d49e2c943947a 100644 --- a/compiler/fndb.lisp +++ b/compiler/fndb.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/fndb.lisp,v 1.121 2003/08/02 11:52:15 gerd Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/fndb.lisp,v 1.122 2003/08/05 14:04:52 gerd Exp $") ;;; ;;; ********************************************************************** ;;; @@ -1146,7 +1146,7 @@ (defknown %cleanup-point () void) (defknown %special-bind (t t) void) (defknown %special-unbind (t) void) -(defknown %listify-rest-args (t index) list (flushable)) +(defknown %listify-rest-args (t index #+x86 t) list (flushable)) (defknown %more-arg-context (t t) (values t index) (flushable)) (defknown %more-arg (t index) t) (defknown %more-arg-values (t index index) * (flushable)) diff --git a/compiler/ir1tran.lisp b/compiler/ir1tran.lisp index 656bcfc786ab3d7851e1b2385d2213a86574e493..0b561267d9e6267794a5e2682d9e3698aba13a72 100644 --- a/compiler/ir1tran.lisp +++ b/compiler/ir1tran.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/ir1tran.lisp,v 1.157 2003/06/11 12:58:08 emarsden Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/ir1tran.lisp,v 1.158 2003/08/05 14:04:52 gerd Exp $") ;;; ;;; ********************************************************************** ;;; @@ -273,25 +273,32 @@ (where-from (info variable where-from name))) (when (and (eq where-from :assumed) (eq kind :global)) (note-undefined-reference name :variable)) + ;; + ;; Paper over the fact that unknown types aren't removed + ;; from the info database when a types gets defined. + (when (unknown-type-p type) + (setq type (specifier-type (type-specifier type))) + (setf (info variable type name) type)) (setf (gethash name *free-variables*) - (cond ((eq kind :alien) - (info variable alien-info name)) - ((eq kind :macro) - (let ((expansion (info variable macro-expansion name)) - (type (type-specifier (info variable type name)))) - `(MACRO . (the ,type ,expansion)))) - (t - (multiple-value-bind - (val valp) - (info variable constant-value name) - (if (and (eq kind :constant) valp) - (make-constant :value val :name name - :type (ctype-of val) - :where-from where-from) - (make-global-var :kind kind :name name :type type - :where-from where-from))))))))) - + (case kind + (:alien + (info variable alien-info name)) + (:macro + (let ((expansion (info variable macro-expansion name))) + `(MACRO . (the ,(type-specifier type) ,expansion)))) + (:constant + (multiple-value-bind (val valp) + (info variable constant-value name) + (if valp + (make-constant :value val :name name + :type (ctype-of val) + :where-from where-from) + (make-global-var :kind kind :name name :type type + :where-from where-from)))) + (t + (make-global-var :kind kind :name name :type type + :where-from where-from))))))) ;;; MAYBE-EMIT-MAKE-LOAD-FORMS -- internal @@ -1134,10 +1141,33 @@ (setf (lambda-var-ignorep var) t))))) (undefined-value)) +(defun process-dynamic-extent-declaration (spec vars fvars) + (declare (list spec vars fvars)) + (dolist (name (cdr spec)) + (let ((var (find-in-bindings-or-fbindings name vars fvars))) + (cond ((null var) + (if (or (lexenv-find name variables) (lexenv-find-function name)) + (compiler-note + "Ignoring free dynamic-extent declaration for ~S." name) + (compiler-warning + "Dynamic-extent declaration for unknown variable ~S." name))) + (t + (when (or (not (lambda-var-p var)) + (let ((arg-info (lambda-var-arg-info var))) + (or (null arg-info) + (not (eq :rest (arg-info-kind arg-info)))))) + (compiler-note + "~@<Ignoring the dynamic-extent declaration of ~s. ~ + Dynamic-extent is currently only implemented for ~ + rest args.~@:>" name)) + (setf (leaf-dynamic-extent var) t))))) + (values)) (defvar *suppress-values-declaration* nil "If true, processing of the VALUES declaration is inhibited.") +(defvar *suppress-dynamic-extent-declaration* nil + "If true, processing of dynamic-extent declarations is inhibited.") ;;; PROCESS-1-DECLARATION -- Internal ;;; @@ -1191,8 +1221,8 @@ `(values ,@types))) cont res 'values)))) (dynamic-extent - (when (policy nil (> speed brevity)) - (compiler-note "DYNAMIC-EXTENT declaration not implemented.")) + (unless *suppress-dynamic-extent-declaration* + (process-dynamic-extent-declaration spec vars fvars)) res) (t (let ((what (first spec))) @@ -1709,7 +1739,9 @@ (arg-vars context-temp count-temp) (when rest - (arg-vals `(%listify-rest-args ,n-context ,n-count))) + (arg-vals `(%listify-rest-args ,n-context ,n-count + #+x86 + ,(leaf-dynamic-extent rest)))) (when morep (arg-vals n-context) (arg-vals n-count)) diff --git a/compiler/locall.lisp b/compiler/locall.lisp index a71ee4ce07c957ff9479bd51b099e2371b33571b..28a9ea27e4a30b023880cf27b7a2bf2550546356 100644 --- a/compiler/locall.lisp +++ b/compiler/locall.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/locall.lisp,v 1.53 2003/04/19 12:31:31 gerd Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/locall.lisp,v 1.54 2003/08/05 14:04:52 gerd Exp $") ;;; ;;; ********************************************************************** ;;; @@ -636,6 +636,9 @@ (when (arg-info-supplied-p info) (call-args t))) (:rest + ;; + ;; We could do something here if the variable is + ;; declared dynamic-extent. (call-args `(list ,@(more-temps))) (return)) (:keyword diff --git a/compiler/node.lisp b/compiler/node.lisp index 127027720e74a8e26865e19e233bba1f716c4299..0b463b03e20f30eede856ec8a2b9ee6a3c41afb1 100644 --- a/compiler/node.lisp +++ b/compiler/node.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/node.lisp,v 1.40 2003/04/13 11:58:50 gerd Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/node.lisp,v 1.41 2003/08/05 14:04:52 gerd Exp $") ;;; ;;; ********************************************************************** ;;; @@ -675,6 +675,9 @@ ;; when Refs and Sets are null, since code can be deleted. (ever-used nil :type boolean) ;; + ;; True if declared dynamic-extent. + (dynamic-extent nil :type boolean) + ;; ;; Some kind of info used by the back end. (info nil)) diff --git a/compiler/x86/call.lisp b/compiler/x86/call.lisp index e99a9ea6eaa79704fd5e553e936fe7d310a4ca64..cb343d063317dee080aa70886b257c41d2c8e7fe 100644 --- a/compiler/x86/call.lisp +++ b/compiler/x86/call.lisp @@ -7,7 +7,7 @@ ;;; Scott Fahlman or slisp-group@cs.cmu.edu. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/call.lisp,v 1.18 2003/08/03 11:27:45 gerd Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/call.lisp,v 1.19 2003/08/05 14:04:51 gerd Exp $") ;;; ;;; ********************************************************************** ;;; @@ -1355,7 +1355,8 @@ (:policy :safe) (:args (context :scs (descriptor-reg) :target src) (count :scs (any-reg) :target ecx)) - (:arg-types * tagged-num) + (:info dynamic-extent) + (:arg-types * tagged-num (:constant t)) (:temporary (:sc unsigned-reg :offset esi-offset :from (:argument 0)) src) (:temporary (:sc unsigned-reg :offset ecx-offset :from (:argument 1)) ecx) (:temporary (:sc unsigned-reg :offset eax-offset) eax) @@ -1372,31 +1373,33 @@ (inst mov result nil-value) (inst jecxz done) (inst lea dst (make-ea :dword :index ecx :scale 2)) - (pseudo-atomic - (allocation dst dst node) - (inst lea dst (make-ea :byte :base dst :disp list-pointer-type)) - ;; Convert the count into a raw value, so we can use the LOOP inst. - (inst shr ecx 2) - ;; Set decrement mode (successive args at lower addresses) - (inst std) - ;; Set up the result. - (move result dst) - ;; Jump into the middle of the loop, 'cause that's were we want - ;; to start. - (inst jmp enter) - (emit-label loop) - ;; Compute a pointer to the next cons. - (inst add dst (* cons-size word-bytes)) - ;; Store a pointer to this cons in the CDR of the previous cons. - (storew dst dst -1 list-pointer-type) - (emit-label enter) - ;; Grab one value and stash it in the car of this cons. - (inst lods eax) - (storew eax dst 0 list-pointer-type) - ;; Go back for more. - (inst loop loop) - ;; NIL out the last cons. - (storew nil-value dst 1 vm:list-pointer-type)) + (let ((*enable-pseudo-atomic* (unless dynamic-extent + *enable-pseudo-atomic*))) + (pseudo-atomic + (allocation dst dst node dynamic-extent) + (inst lea dst (make-ea :byte :base dst :disp list-pointer-type)) + ;; Convert the count into a raw value, so we can use the LOOP inst. + (inst shr ecx 2) + ;; Set decrement mode (successive args at lower addresses) + (inst std) + ;; Set up the result. + (move result dst) + ;; Jump into the middle of the loop, 'cause that's were we want + ;; to start. + (inst jmp enter) + (emit-label loop) + ;; Compute a pointer to the next cons. + (inst add dst (* cons-size word-bytes)) + ;; Store a pointer to this cons in the CDR of the previous cons. + (storew dst dst -1 list-pointer-type) + (emit-label enter) + ;; Grab one value and stash it in the car of this cons. + (inst lods eax) + (storew eax dst 0 list-pointer-type) + ;; Go back for more. + (inst loop loop) + ;; NIL out the last cons. + (storew nil-value dst 1 vm:list-pointer-type))) (emit-label done)))) ;;; Return the location and size of the more arg glob created by Copy-More-Arg. diff --git a/compiler/x86/macros.lisp b/compiler/x86/macros.lisp index 7a8042d63dce39a5c5bd5c02deac2e90ea1c9a2f..c836bc614d7df3cb38aea47f732701a0a42f25e4 100644 --- a/compiler/x86/macros.lisp +++ b/compiler/x86/macros.lisp @@ -7,7 +7,7 @@ ;;; Scott Fahlman or slisp-group@cs.cmu.edu. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/macros.lisp,v 1.17 2003/08/03 11:27:45 gerd Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/macros.lisp,v 1.18 2003/08/05 14:04:51 gerd Exp $") ;;; ;;; ********************************************************************** ;;; @@ -132,117 +132,144 @@ ;;; this set the following variable to True. (defparameter *maybe-use-inline-allocation* t) -;;;; Call into C. -(defun allocation (alloc-tn size &optional inline) +(defun load-size (alloc-tn dst-tn size) + (unless (and (tn-p size) (location= alloc-tn size)) + (inst mov dst-tn size))) + +(defun inline-allocation (alloc-tn size) + (let ((ok (gen-label))) + ;; + ;; Load the size first so that the size can be in the same + ;; register as alloc-tn. + (load-size alloc-tn alloc-tn size) + ;; + (inst add alloc-tn + (make-symbol-value-ea '*current-region-free-pointer*)) + (inst cmp alloc-tn + (make-symbol-value-ea '*current-region-end-addr*)) + (inst jmp :be OK) + ;; + ;; Dispatch to the appropriate overflow routine. There is a + ;; routine for each destination. + (ecase (tn-offset alloc-tn) + (#.eax-offset + (inst call (make-fixup (extern-alien-name "alloc_overflow_eax") + :foreign))) + (#.ecx-offset + (inst call (make-fixup (extern-alien-name "alloc_overflow_ecx") + :foreign))) + (#.edx-offset + (inst call (make-fixup (extern-alien-name "alloc_overflow_edx") + :foreign))) + (#.ebx-offset + (inst call (make-fixup (extern-alien-name "alloc_overflow_ebx") + :foreign))) + (#.esi-offset + (inst call (make-fixup (extern-alien-name "alloc_overflow_esi") + :foreign))) + (#.edi-offset + (inst call (make-fixup (extern-alien-name "alloc_overflow_edi") + :foreign)))) + (emit-label ok) + (inst xchg (make-symbol-value-ea '*current-region-free-pointer*) + alloc-tn)) + (values)) + +(defun not-inline-allocation (alloc-tn size) + ;; C call to allocate via dispatch routines. Each destination has a + ;; special entry point. The size may be a register or a constant. + (ecase (tn-offset alloc-tn) + (#.eax-offset + (case size + (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_eax") + :foreign))) + (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_eax") + :foreign))) + (t + (load-size alloc-tn eax-tn size) + (inst call (make-fixup (extern-alien-name "alloc_to_eax") + :foreign))))) + (#.ecx-offset + (case size + (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_ecx") + :foreign))) + (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_ecx") + :foreign))) + (t + (load-size alloc-tn ecx-tn size) + (inst call (make-fixup (extern-alien-name "alloc_to_ecx") + :foreign))))) + (#.edx-offset + (case size + (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_edx") + :foreign))) + (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_edx") + :foreign))) + (t + (load-size alloc-tn edx-tn size) + (inst call (make-fixup (extern-alien-name "alloc_to_edx") + :foreign))))) + (#.ebx-offset + (case size + (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_ebx") + :foreign))) + (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_ebx") + :foreign))) + (t + (load-size alloc-tn ebx-tn size) + (inst call (make-fixup (extern-alien-name "alloc_to_ebx") + :foreign))))) + (#.esi-offset + (case size + (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_esi") + :foreign))) + (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_esi") + :foreign))) + (t + (load-size alloc-tn esi-tn size) + (inst call (make-fixup (extern-alien-name "alloc_to_esi") + :foreign))))) + (#.edi-offset + (case size + (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_edi") + :foreign))) + (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_edi") + :foreign))) + (t + (load-size alloc-tn edi-tn size) + (inst call (make-fixup (extern-alien-name "alloc_to_edi") + :foreign)))))) + (values)) + +;;; +;;; Allocate SIZE bytes from the stack, storing a pointer to the +;;; allocated memory in ALLOC-TN. +;;; +(defun stack-allocation (alloc-tn size) + (load-size alloc-tn alloc-tn size) + (inst neg alloc-tn) + (inst add alloc-tn esp-tn) + (inst and alloc-tn #xfffffff8) ;align on double-word boundary + (inst mov esp-tn alloc-tn) + (values)) + +(defun allocation (alloc-tn size &optional inline dynamic-extent) "Allocate an object with a size in bytes given by Size. - The size may be an integer of a TN. + The size may be an integer or a TN. If Inline is a VOP node-var then it is used to make an appropriate - speed vs size decision." - (flet ((load-size (dst-tn size) - (unless (and (tn-p size) (location= alloc-tn size)) - (inst mov dst-tn size)))) - (let ((alloc-tn-offset (tn-offset alloc-tn))) - (if (and *maybe-use-inline-allocation* - (or (null inline) (policy inline (>= speed space))) - (backend-featurep :gencgc)) - ;; Inline allocation with GENCGC. - (let ((ok (gen-label))) - ;; Load the size first so that the size can be in the same - ;; register as alloc-tn. - (load-size alloc-tn size) - (inst add alloc-tn - (make-symbol-value-ea '*current-region-free-pointer*)) - (inst cmp alloc-tn - (make-symbol-value-ea '*current-region-end-addr*)) - (inst jmp :be OK) - ;; Dispatch to the appropriate overflow routine. There is a - ;; routine for each destination. - (ecase alloc-tn-offset - (#.eax-offset - (inst call (make-fixup (extern-alien-name "alloc_overflow_eax") - :foreign))) - (#.ecx-offset - (inst call (make-fixup (extern-alien-name "alloc_overflow_ecx") - :foreign))) - (#.edx-offset - (inst call (make-fixup (extern-alien-name "alloc_overflow_edx") - :foreign))) - (#.ebx-offset - (inst call (make-fixup (extern-alien-name "alloc_overflow_ebx") - :foreign))) - (#.esi-offset - (inst call (make-fixup (extern-alien-name "alloc_overflow_esi") - :foreign))) - (#.edi-offset - (inst call (make-fixup (extern-alien-name "alloc_overflow_edi") - :foreign)))) - (emit-label ok) - (inst xchg (make-symbol-value-ea '*current-region-free-pointer*) - alloc-tn)) - ;; C call to allocate via dispatch routines. Each - ;; destination has a special entry point. The size may be a - ;; register or a constant. - (ecase alloc-tn-offset - (#.eax-offset - (case size - (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_eax") - :foreign))) - (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_eax") - :foreign))) - (t - (load-size eax-tn size) - (inst call (make-fixup (extern-alien-name "alloc_to_eax") - :foreign))))) - (#.ecx-offset - (case size - (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_ecx") - :foreign))) - (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_ecx") - :foreign))) - (t - (load-size ecx-tn size) - (inst call (make-fixup (extern-alien-name "alloc_to_ecx") - :foreign))))) - (#.edx-offset - (case size - (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_edx") - :foreign))) - (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_edx") - :foreign))) - (t - (load-size edx-tn size) - (inst call (make-fixup (extern-alien-name "alloc_to_edx") - :foreign))))) - (#.ebx-offset - (case size - (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_ebx") - :foreign))) - (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_ebx") - :foreign))) - (t - (load-size ebx-tn size) - (inst call (make-fixup (extern-alien-name "alloc_to_ebx") - :foreign))))) - (#.esi-offset - (case size - (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_esi") - :foreign))) - (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_esi") - :foreign))) - (t - (load-size esi-tn size) - (inst call (make-fixup (extern-alien-name "alloc_to_esi") - :foreign))))) - (#.edi-offset - (case size - (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_edi") - :foreign))) - (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_edi") - :foreign))) - (t - (load-size edi-tn size) - (inst call (make-fixup (extern-alien-name "alloc_to_edi") - :foreign))))))))) + speed vs size decision. If Dynamic-Extent is true, and otherwise + appropriate, allocate from the stack." + (cond ((and inline + dynamic-extent + (policy inline (> speed safety))) + (stack-allocation alloc-tn size)) + ((and *maybe-use-inline-allocation* + (or (null inline) + (policy inline (>= speed space))) + (backend-featurep :gencgc)) + (inline-allocation alloc-tn size)) + (t + (not-inline-allocation alloc-tn size))) (values)) (defmacro with-fixed-allocation ((result-tn type-code size &optional inline) diff --git a/general-info/release-19a.txt b/general-info/release-19a.txt index 114a2ba9b318bb4dd2b14921dad63a8db9c49c18..636dd8c3c91be36005406265396c5e9cd5528757 100644 --- a/general-info/release-19a.txt +++ b/general-info/release-19a.txt @@ -168,6 +168,11 @@ New in this release: default to preserve current behavior. Set the version to :newest to create versions. - LDB backtrace on x86. + - On x86, the &REST arg list of a non-local function is allocated + on the stack if declared DYNAMIC-EXTENT, and speed is greater + than safety. Be warned that all bets are off if a + stack-allocated object or parts of it escape; CMUCL might + crash or format your hard disk. * Numerous improvements to the PCL implementation of CLOS: - Gerd's PCL has been added, which fixes numerous bugs and ANSI/