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/