diff --git a/asdf.asd b/asdf.asd
index 1f1ec4c2056d794b539c5885e9be1039d8bdec88..c92fc6d74d9df1d06b1f95378d11d2ef4622db55 100644
--- a/asdf.asd
+++ b/asdf.asd
@@ -74,7 +74,7 @@
   :licence "MIT"
   :description "Another System Definition Facility"
   :long-description "ASDF builds Common Lisp software organized into defined systems."
-  :version "2.32.2" ;; to be automatically updated by make bump-version
+  :version "2.32.6" ;; to be automatically updated by make bump-version
   :depends-on ()
   #+asdf3 :encoding #+asdf3 :utf-8
   ;; For most purposes, asdf itself specially counts as a builtin system.
diff --git a/bin/asdf-builder b/bin/asdf-builder
index 017c211a48d44baf01747a81714952ced06a466d..f2cd43c895d86195730b02c13cd9f93fc7287e27 100755
--- a/bin/asdf-builder
+++ b/bin/asdf-builder
@@ -4,10 +4,10 @@
 (load (make-pathname :name "prelude" :type "lisp" :defaults *load-pathname*)
   :verbose nil :print nil)
 
-(defpackage :asdf-builder (:use :cl :asdf/driver :asdf/operate :asdf :fare-utils :inferior-shell))
+(defpackage :asdf-builder (:use :cl :uiop :asdf/operate :asdf :fare-utils :inferior-shell))
 (in-package :asdf-builder)
 
-(asdf-debug)
+(uiop-debug)
 
 (defun build-asdf ()
   "Make sure asdf.lisp is built"
@@ -104,7 +104,7 @@
       (error "Destination ~S already exists, not taking chances - you can delete it yourself."
              destination))
     (ensure-directories-exist destination)
-    (run (format nil "cd ~S && cp -pHux ~{~S ~} ~S"
+    (run (format nil "cd ~S && cp -pHux --parents ~{~S ~} ~S"
                  /base/ /files/ /destination/) :show t)
     (run (format nil "tar zcfC ~S ~S ~S/"
                  /tarball/ /build-dir/ name) :show t)
@@ -113,8 +113,7 @@
 
 (defun driver-files ()
   (DBG :df
-  (list* "uiop.asd" "../asdf-driver.asd" "version.lisp-expr"
-         (system-source-files :asdf-driver))))
+  (list* "uiop.asd" "asdf-driver.asd" (system-source-files :uiop))))
 (defun driver-name ()
   (format nil "uiop-~A" *version*))
 (defun make-driver-tarball ()
diff --git a/contrib/debug.lisp b/contrib/debug.lisp
deleted file mode 100644
index e3d05d533472b9469a66256a7a7dc312c77d8905..0000000000000000000000000000000000000000
--- a/contrib/debug.lisp
+++ /dev/null
@@ -1,122 +0,0 @@
-;;;;; A few essential debugging utilities by Faré,
-;;;;; to be loaded in the *PACKAGE* that you wish to debug.
-;;
-;; We want debugging utilities in the _current_ package,
-;; so we don't have to either change the package structure
-;; or use heavy package prefixes everywhere.
-;;
-;; The short names of symbols below are unlikely to clash
-;; with global bindings of any well-designed source file being debugged,
-;; yet are quite practical in a debugging session.
-#|
-;;; If ASDF is already loaded,
-;;; you can load these utilities in the current package as follows:
-(d:asdf-debug)
-;; which if you left the :D nickname to asdf/driver is short for:
-(asdf/utility::asdf-debug)
-
-;; The above macro can be configured to load any other debugging utility
-;; that you may prefer to this one, with your customizations,
-;; by setting the variable
-;;    asdf-utility:*asdf-debug-utility*
-;; to a form that evaluates to a designator of the pathname to your file.
-;; For instance, on a home directory shared via NFS with different names
-;; on different machines, with your debug file in ~/lisp/debug-utils.lisp
-;; you could in your ~/.sbclrc have the following configuration setting:
-(require :asdf)
-(setf asdf/utility:*asdf-debug-utility*
-      '(asdf/pathname:subpathname (asdf/os:user-homedir) "lisp/debug-utils.lisp"))
-
-;;; If ASDF is not loaded (for instance, when debugging ASDF itself),
-;;; Try the below, fixing the pathname to point to this file:
-(eval-when (:compile-toplevel :load-toplevel :execute)
-  (let ((kw (read-from-string (format nil ":DBG-~A" (package-name *package*)))))
-    (unless (member kw *features*)
-      (load "/home/tunes/cl/asdf/contrib/debug.lisp"))))
-
-|#
-
-;;; Here we define the magic package-dependent feature.
-;;; With it, you should be able to use #+DBG-/PACKAGE-NAME/
-;;; to annotate your debug statements, e.g. upper-case #+DBG-ASDF
-;;; This will be all upper-case even in lower-case lisps.
-
-(eval-when (:compile-toplevel :load-toplevel :execute)
-  (let ((kw (read-from-string
-             (format nil ":DBG-~:@(~A~)" (package-name *package*)))))
-    (pushnew kw *features*)))
-
-;;; Now for the debugging stuff itself.
-;;; First, my all-purpose print-debugging macro
-(defmacro DBG (tag &rest exprs)
-  "simple debug statement macro:
-TAG is typically a constant string or keyword,
-but in general is an expression returning a tag to be printed first;
-if the expression returns NIL, nothing is printed.
-EXPRS are expressions, which when the TAG was not NIL are evaluated in order,
-with their source code then their return values being printed each time.
-The last expresion is *always* evaluated and its values are returned,
-but its source and return values are only printed if TAG was not NIL;
-previous expressions are not evaluated at all if TAG returned NIL.
-The macro expansion has relatively low overhead in space of time."
-  (let* ((last-expr (car (last exprs)))
-         (other-exprs (butlast exprs))
-         (tag-var (gensym "TAG"))
-         (thunk-var (gensym "THUNK")))
-    `(let ((,tag-var ,tag))
-       (flet ,(when exprs `((,thunk-var () ,last-expr)))
-         (if ,tag-var
-             (DBG-helper ,tag-var
-                         (list ,@(loop :for x :in other-exprs :collect
-                                       `(cons ',x #'(lambda () ,x))))
-                         ',last-expr ,(if exprs `#',thunk-var nil))
-             ,(if exprs `(,thunk-var) '(values)))))))
-
-(defun DBG-helper (tag expressions-thunks last-expression last-thunk)
-  ;; Helper for the above debugging macro
-  (labels
-      ((f (stream fmt &rest args)
-         (with-standard-io-syntax
-           (let ((*print-readably* nil)
-                 (*package* (find-package :cl)))
-             (apply 'format stream fmt args)
-             (finish-output stream))))
-       (z (stream)
-         (f stream "~&"))
-       (e (fmt arg)
-         (f *error-output* fmt arg))
-       (x (expression thunk)
-         (e "~&  ~S => " expression)
-         (let ((results (multiple-value-list (funcall thunk))))
-           (e "~{~S~^ ~}~%" results)
-           (apply 'values results))))
-    (map () #'z (list *standard-output* *error-output* *trace-output*))
-    (e "~A~%" tag)
-    (loop :for (expression . thunk) :in expressions-thunks
-          :do (x expression thunk))
-    (if last-thunk
-        (x last-expression last-thunk)
-        (values))))
-
-
-;;; Quick definitions for use at the REPL
-(defun w (&rest x) (format t "~&~{~S~^ ~}~%" x)) ;Write, space separated + LF
-(defun a (&rest x) (format t "~&~{~A~}~%" x)) ;print Anything, no separator, LF
-(defun e (x) (cons x (ignore-errors (list (eval x))))) ;eValuate
-(defmacro x (x) `(format t "~&~S => ~S~%" ',x ,x)) ;eXamine
-(defmacro !a (&rest foo) ; define! Alias
-  `(progn ,@(loop :for (alias name) :on foo :by #'cddr
-                  :collect (if (macro-function name)
-                               `(defmacro ,alias (&rest x) `(,',name ,@x))
-                               `(defun ,alias (&rest x) (apply ',name x))))))
-
-;;; common aliases
-(!a
- d describe
- ap apropos
- !p defparameter
- m1 macroexpand-1)
-
-;;; SLIME integration
-(when (find-package :swank)
-  (eval (read-from-string "(!a i swank:inspect-in-emacs)")))
diff --git a/contrib/debug.lisp b/contrib/debug.lisp
new file mode 120000
index 0000000000000000000000000000000000000000..a801aa750ab383a6b08b295d926e5c792692f64d
--- /dev/null
+++ b/contrib/debug.lisp
@@ -0,0 +1 @@
+../uiop/contrib/debug.lisp
\ No newline at end of file
diff --git a/header.lisp b/header.lisp
index 6909aa8ac32ae4cc0eb36f87593c04f1356e2d63..fbc1e78532c7798589ce7d0f8e8e86439b39dc24 100644
--- a/header.lisp
+++ b/header.lisp
@@ -1,5 +1,5 @@
 ;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp -*-
-;;; This is ASDF 2.32.2: Another System Definition Facility.
+;;; This is ASDF 2.32.6: Another System Definition Facility.
 ;;;
 ;;; Feedback, bug reports, and patches are all welcome:
 ;;; please mail to <asdf-devel@common-lisp.net>.
diff --git a/test/run-tests.sh b/test/run-tests.sh
index e26c27eaf9366fbda24812ea760ba73d6e2c73c2..557bb5ebb38d7fc1f9436614362afb860081a4d6 100755
--- a/test/run-tests.sh
+++ b/test/run-tests.sh
@@ -265,6 +265,7 @@ upgrade_methods () {
 'load-asdf-lisp'compile-load-asdf
 'load-asdf-lisp'load-asdf-fasl
 ()'load-asdf-fasl
+'load-asdf-lisp-and-test-uiop'load-asdf-fasl
 EOF
 }
 extract_tagged_asdf () {
diff --git a/test/script-support.lisp b/test/script-support.lisp
index afab15b1937c08dea76510653e0b1ff80c94605e..0ad0721905b30529a8a46359bf6e34c248ffade0 100644
--- a/test/script-support.lisp
+++ b/test/script-support.lisp
@@ -356,12 +356,14 @@ is bound, write a message and exit on an error.  If
 (defmacro with-asdf-conditions ((&optional verbose) &body body)
   `(call-with-asdf-conditions #'(lambda () ,@body) ,verbose))
 
+#+clisp (trace compile-file)
+
 (defun compile-asdf (&optional tag verbose)
   (let* ((alisp (asdf-lisp tag))
          (afasl (asdf-fasl tag))
          (tmp (make-pathname :name "asdf-tmp" :defaults afasl)))
     (ensure-directories-exist afasl)
-    (multiple-value-bind (result warnings-p errors-p)
+    (multiple-value-bind (result warnings-p failure-p)
         (compile-file alisp :output-file tmp #-gcl :verbose #-gcl verbose :print verbose)
       (flet ((bad (key)
                (when result (ignore-errors (delete-file result)))
@@ -371,13 +373,20 @@ is bound, write a message and exit on an error.  If
                (rename-file tmp afasl)
                key))
         (cond
-          (errors-p (bad :errors))
+          ((null result)
+           (bad :no-output))
+          (failure-p
+           (or
+            #+clisp (good :expected-full-warnings)
+            (bad :unexpected-full-warnings)))
           (warnings-p
            (or
+            ;; CLISP has full warnings for method redefinition in eval-when.
+            ;; CMUCL: ?
             ;; ECL 11.1.1 has spurious warnings, same with XCL 0.0.0.291.
             ;; SCL has no warning but still raises the warningp flag since 2.20.15 (?)
-            #+(or cmu ecl scl xcl) (good :expected-warnings)
-          (bad :unexpected-warnings)))
+            #+(or clisp cmu ecl scl xcl) (good :expected-style-warnings)
+            (bad :unexpected-style-warnings)))
           (t (good :success)))))))
 
 (defun maybe-compile-asdf (&optional tag)
@@ -401,22 +410,29 @@ is bound, write a message and exit on an error.  If
        (leave-test "Testsuite failed: unable to find ASDF source" 3))
       (:previously-compiled
        (leave-test "Reusing previously-compiled ASDF" 0))
-      (:errors
-       (leave-test "Testsuite failed: ASDF compiled with ERRORS" 2))
-      (:unexpected-warnings
+      (:no-output
+       (leave-test "Testsuite failed: ASDF compilation failed without output" 1))
+      (:unexpected-full-warnings
+       (leave-test "Testsuite failed: ASDF compiled with unexpected full warnings" 1))
+      (:expected-full-warnings
+       (leave-test "ASDF compiled with full warnings, ignored for your implementation" 0))
+      (:unexpected-style-warnings
        (leave-test "Testsuite failed: ASDF compiled with unexpected warnings" 1))
-      (:expected-warnings
-       (leave-test "ASDF compiled with warnings, ignored for your implementation" 0))
+      (:expected-style-warnings
+       (leave-test "ASDF compiled with style-warnings, ignored for your implementation" 0))
       (:success
        (leave-test "ASDF compiled cleanly" 0)))))
 
 (defun compile-load-asdf (&optional tag)
   ;; emulate the way asdf upgrades itself: load source, compile, load fasl.
   (load-asdf-lisp tag)
-  (ecase (compile-asdf tag)
-    ((:errors :unexpected-warnings) (leave-test "failed to compile ASDF" 1))
-    ((:expected-warnings :success)
-     (load-asdf-fasl tag))))
+  (let ((results (compile-asdf tag)))
+    (ecase results
+      ((:no-output :unexpected-full-warnings :unexpected-style-warnings)
+       (warn "ASDF compiled with ~S" results)
+       (leave-test "failed to compile ASDF" 1))
+      ((:expected-full-warnings :expected-style-warnings :success)
+       (load-asdf-fasl tag)))))
 
 ;;; Now, functions to compile and load ASDF.
 
@@ -501,6 +517,17 @@ is bound, write a message and exit on an error.  If
   (setf *package* (find-package :asdf-test))
   t)
 
+(defun load-asdf-lisp-and-test-uiop (&optional tag)
+  (load-asdf-lisp tag)
+  (configure-asdf)
+  (register-directory *asdf-directory*)
+  (register-directory *uiop-directory*)
+  (register-directory *test-directory*)
+  (DBG :lalatu (asymval :*central-registry*))
+  (quietly
+   (acall :oos (asym :load-op) :uiop))
+  (acall :oos (asym :load-op) :test-module-depend))
+
 (defun load-asdf (&optional tag)
   #+gcl2.6 (load-asdf-lisp tag) #-gcl2.6
   (load-asdf-fasl tag)
@@ -550,6 +577,10 @@ is bound, write a message and exit on an error.  If
          (funcall old-method tag))))
     (when (find-package :asdf)
       (configure-asdf))
+    (when (and (null old-method) (eq 'load-asdf-fasl new-method) (not (probe-file (asdf-fasl))))
+      (if (ignore-errors (funcall 'require "asdf") t)
+          (leave-test "Your failed to compile ASDF before your run (test-upgrade ()'load-asdf-fasl ...)"  1)
+          (leave-test "Your Lisp doesn't provide ASDF. Skipping (test-upgrade ()'load-asdf-fasl ...)"  0)))
     (format t "Now loading new asdf via method ~A~%" new-method)
     (funcall new-method)
     (format t "Testing it~%")
@@ -569,7 +600,7 @@ is bound, write a message and exit on an error.  If
 #| For the record, the following form is sometimes useful to insert in
  asdf/plan:compute-action-stamp to find out what's happening.
  It depends on the DBG macro in contrib/debug.lisp,
- that you should load in your asdf/plan by inserting an (asdf-debug) form in it.
+ that you should load in your asdf/plan by inserting an (uiop-debug) form in it.
 
  (let ((action-path (action-path (cons o c)))) (DBG :cas action-path just-done plan stamp-lookup out-files in-files out-op op-time dep-stamp out-stamps in-stamps missing-in missing-out all-present earliest-out latest-in up-to-date-p done-stamp (operation-done-p o c)
 ;;; blah
diff --git a/asdf-driver.asd b/uiop/asdf-driver.asd
similarity index 100%
rename from asdf-driver.asd
rename to uiop/asdf-driver.asd
diff --git a/uiop/contrib b/uiop/contrib
deleted file mode 120000
index 7a6a8fee3fb7ce94aa2637e597aa7cae20aa3393..0000000000000000000000000000000000000000
--- a/uiop/contrib
+++ /dev/null
@@ -1 +0,0 @@
-../contrib
\ No newline at end of file
diff --git a/uiop/contrib/debug.lisp b/uiop/contrib/debug.lisp
new file mode 100644
index 0000000000000000000000000000000000000000..e3d05d533472b9469a66256a7a7dc312c77d8905
--- /dev/null
+++ b/uiop/contrib/debug.lisp
@@ -0,0 +1,122 @@
+;;;;; A few essential debugging utilities by Faré,
+;;;;; to be loaded in the *PACKAGE* that you wish to debug.
+;;
+;; We want debugging utilities in the _current_ package,
+;; so we don't have to either change the package structure
+;; or use heavy package prefixes everywhere.
+;;
+;; The short names of symbols below are unlikely to clash
+;; with global bindings of any well-designed source file being debugged,
+;; yet are quite practical in a debugging session.
+#|
+;;; If ASDF is already loaded,
+;;; you can load these utilities in the current package as follows:
+(d:asdf-debug)
+;; which if you left the :D nickname to asdf/driver is short for:
+(asdf/utility::asdf-debug)
+
+;; The above macro can be configured to load any other debugging utility
+;; that you may prefer to this one, with your customizations,
+;; by setting the variable
+;;    asdf-utility:*asdf-debug-utility*
+;; to a form that evaluates to a designator of the pathname to your file.
+;; For instance, on a home directory shared via NFS with different names
+;; on different machines, with your debug file in ~/lisp/debug-utils.lisp
+;; you could in your ~/.sbclrc have the following configuration setting:
+(require :asdf)
+(setf asdf/utility:*asdf-debug-utility*
+      '(asdf/pathname:subpathname (asdf/os:user-homedir) "lisp/debug-utils.lisp"))
+
+;;; If ASDF is not loaded (for instance, when debugging ASDF itself),
+;;; Try the below, fixing the pathname to point to this file:
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (let ((kw (read-from-string (format nil ":DBG-~A" (package-name *package*)))))
+    (unless (member kw *features*)
+      (load "/home/tunes/cl/asdf/contrib/debug.lisp"))))
+
+|#
+
+;;; Here we define the magic package-dependent feature.
+;;; With it, you should be able to use #+DBG-/PACKAGE-NAME/
+;;; to annotate your debug statements, e.g. upper-case #+DBG-ASDF
+;;; This will be all upper-case even in lower-case lisps.
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (let ((kw (read-from-string
+             (format nil ":DBG-~:@(~A~)" (package-name *package*)))))
+    (pushnew kw *features*)))
+
+;;; Now for the debugging stuff itself.
+;;; First, my all-purpose print-debugging macro
+(defmacro DBG (tag &rest exprs)
+  "simple debug statement macro:
+TAG is typically a constant string or keyword,
+but in general is an expression returning a tag to be printed first;
+if the expression returns NIL, nothing is printed.
+EXPRS are expressions, which when the TAG was not NIL are evaluated in order,
+with their source code then their return values being printed each time.
+The last expresion is *always* evaluated and its values are returned,
+but its source and return values are only printed if TAG was not NIL;
+previous expressions are not evaluated at all if TAG returned NIL.
+The macro expansion has relatively low overhead in space of time."
+  (let* ((last-expr (car (last exprs)))
+         (other-exprs (butlast exprs))
+         (tag-var (gensym "TAG"))
+         (thunk-var (gensym "THUNK")))
+    `(let ((,tag-var ,tag))
+       (flet ,(when exprs `((,thunk-var () ,last-expr)))
+         (if ,tag-var
+             (DBG-helper ,tag-var
+                         (list ,@(loop :for x :in other-exprs :collect
+                                       `(cons ',x #'(lambda () ,x))))
+                         ',last-expr ,(if exprs `#',thunk-var nil))
+             ,(if exprs `(,thunk-var) '(values)))))))
+
+(defun DBG-helper (tag expressions-thunks last-expression last-thunk)
+  ;; Helper for the above debugging macro
+  (labels
+      ((f (stream fmt &rest args)
+         (with-standard-io-syntax
+           (let ((*print-readably* nil)
+                 (*package* (find-package :cl)))
+             (apply 'format stream fmt args)
+             (finish-output stream))))
+       (z (stream)
+         (f stream "~&"))
+       (e (fmt arg)
+         (f *error-output* fmt arg))
+       (x (expression thunk)
+         (e "~&  ~S => " expression)
+         (let ((results (multiple-value-list (funcall thunk))))
+           (e "~{~S~^ ~}~%" results)
+           (apply 'values results))))
+    (map () #'z (list *standard-output* *error-output* *trace-output*))
+    (e "~A~%" tag)
+    (loop :for (expression . thunk) :in expressions-thunks
+          :do (x expression thunk))
+    (if last-thunk
+        (x last-expression last-thunk)
+        (values))))
+
+
+;;; Quick definitions for use at the REPL
+(defun w (&rest x) (format t "~&~{~S~^ ~}~%" x)) ;Write, space separated + LF
+(defun a (&rest x) (format t "~&~{~A~}~%" x)) ;print Anything, no separator, LF
+(defun e (x) (cons x (ignore-errors (list (eval x))))) ;eValuate
+(defmacro x (x) `(format t "~&~S => ~S~%" ',x ,x)) ;eXamine
+(defmacro !a (&rest foo) ; define! Alias
+  `(progn ,@(loop :for (alias name) :on foo :by #'cddr
+                  :collect (if (macro-function name)
+                               `(defmacro ,alias (&rest x) `(,',name ,@x))
+                               `(defun ,alias (&rest x) (apply ',name x))))))
+
+;;; common aliases
+(!a
+ d describe
+ ap apropos
+ !p defparameter
+ m1 macroexpand-1)
+
+;;; SLIME integration
+(when (find-package :swank)
+  (eval (read-from-string "(!a i swank:inspect-in-emacs)")))
diff --git a/uiop/filesystem.lisp b/uiop/filesystem.lisp
index 85e2644c8e0262895bb777f1037c4e504a4e4e90..65261708b56858fc7ce1c088cfb5caf57787aa57 100644
--- a/uiop/filesystem.lisp
+++ b/uiop/filesystem.lisp
@@ -418,8 +418,10 @@ TRUENAMIZE uses TRUENAMIZE to resolve as many symlinks as possible."
     (loop :for namestring :in (split-string string :separator (string (inter-directory-separator)))
           :collect (apply 'parse-native-namestring namestring constraints)))
 
-  (defun getenv-pathname (x &rest constraints &key on-error &allow-other-keys)
+  (defun getenv-pathname (x &rest constraints &key ensure-directory want-directory on-error &allow-other-keys)
+    ;; For backward compatibility with ASDF 2, want-directory implies ensure-directory
     (apply 'parse-native-namestring (getenvp x)
+           :ensure-directory (or ensure-directory want-directory)
            :on-error (or on-error
                          `(error "In (~S ~S), invalid pathname ~*~S: ~*~?" getenv-pathname ,x))
            constraints))
diff --git a/uiop/image.lisp b/uiop/image.lisp
index 728694460de92ddd9e8d5a783d677b49276d3e0f..3f2b2a4797d7492dadbf99ac1ace71e3d5bfc066 100644
--- a/uiop/image.lisp
+++ b/uiop/image.lisp
@@ -34,6 +34,9 @@
   (defvar *image-restore-hook* nil
     "Functions to call (in reverse order) when the image is restored")
 
+  (defvar *image-restored-p* nil
+    "Has the image been restored? A boolean, or :in-progress while restoring, :in-regress while dumping")
+
   (defvar *image-prelude* nil
     "a form to evaluate, or string containing forms to read and evaluate
 when the image is restarted, but before the entry point is called.")
@@ -226,10 +229,17 @@ if we are not called from a directly executable image."
                           ((:lisp-interaction *lisp-interaction*) *lisp-interaction*)
                           ((:restore-hook *image-restore-hook*) *image-restore-hook*)
                           ((:prelude *image-prelude*) *image-prelude*)
-                          ((:entry-point *image-entry-point*) *image-entry-point*))
+                          ((:entry-point *image-entry-point*) *image-entry-point*)
+                          (if-already-restored '(cerror "RUN RESTORE-IMAGE ANYWAY")))
+    (when *image-restored-p*
+      (if if-already-restored
+          (call-function if-already-restored "Image already ~:[being ~;~]restored" (eq *image-restored-p* t))
+          (return-from restore-image)))
     (with-fatal-condition-handler ()
+      (setf *image-restored-p* :in-progress)
       (call-image-restore-hook)
       (standard-eval-thunk *image-prelude*)
+      (setf *image-restored-p* t)
       (let ((results (multiple-value-list
                       (if *image-entry-point*
                           (call-function *image-entry-point*)
@@ -248,8 +258,10 @@ if we are not called from a directly executable image."
                                 ((:dump-hook *image-dump-hook*) *image-dump-hook*))
     (declare (ignorable filename output-name executable))
     (setf *image-dumped-p* (if executable :executable t))
+    (setf *image-restored-p* :in-regress)
     (standard-eval-thunk *image-postlude*)
     (call-image-dump-hook)
+    (setf *image-restored-p* nil)
     #-(or clisp clozure cmu lispworks sbcl scl)
     (when executable
       (error "Dumping an executable is not supported on this implementation! Aborting."))
diff --git a/uiop/lisp-build.lisp b/uiop/lisp-build.lisp
index 1522d336e8bec514b98022208828ec8cb75c974e..03bf43b7db47d29a5640302ce304058b1f66f566 100644
--- a/uiop/lisp-build.lisp
+++ b/uiop/lisp-build.lisp
@@ -53,7 +53,7 @@ Note that ASDF ALWAYS raises an error if it fails to create an output file when
     "Get current compiler optimization settings, ready to PROCLAIM again"
     (let ((settings '(speed space safety debug compilation-speed #+(or cmu scl) c::brevity)))
       #-(or clisp clozure cmu ecl sbcl scl)
-      (warn "xcvb-driver::get-optimization-settings does not support your implementation. Please help me fix that.")
+      (warn "~S does not support your implementation. Please help me fix that." 'get-optimization-settings)
       #.`(loop :for x :in settings
                ,@(or #+clozure '(:for v :in '(ccl::*nx-speed* ccl::*nx-space* ccl::*nx-safety* ccl::*nx-debug* ccl::*nx-cspeed*))
                      #+ecl '(:for v :in '(c::*speed* c::*space* c::*safety* c::*debug*))
diff --git a/uiop/utility.lisp b/uiop/utility.lisp
index 5a691f229daa17ba973a2a84bc71f250cb86ded4..5248c8c26b5adc201d472edccad59bf4cf754a83 100644
--- a/uiop/utility.lisp
+++ b/uiop/utility.lisp
@@ -12,7 +12,7 @@
    #+ecl #:use-ecl-byte-compiler-p #+mcl #:probe-posix)
   (:export
    ;; magic helper to define debugging functions:
-   #:asdf-debug #:load-asdf-debug-utility #:*asdf-debug-utility*
+   #:uiop-debug #:load-uiop-debug-utility #:*uiop-debug-utility*
    #:undefine-function #:undefine-functions #:defun* #:defgeneric* #:with-upgradability ;; (un)defining functions
    #:if-let ;; basic flow control
    #:while-collecting #:appendf #:length=n-p #:remove-plist-keys #:remove-plist-key ;; lists and plists
@@ -90,22 +90,22 @@
 
 ;;; Magic debugging help. See contrib/debug.lisp
 (with-upgradability ()
-  (defvar *asdf-debug-utility*
+  (defvar *uiop-debug-utility*
     '(or (ignore-errors
-          (symbol-call :asdf :system-relative-pathname :asdf "contrib/debug.lisp"))
-      (merge-pathnames "cl/asdf/contrib/debug.lisp" (user-homedir-pathname)))
+          (symbol-call :asdf :system-relative-pathname :uiop "contrib/debug.lisp"))
+      (symbol-call :uiop/pathname :subpathname (user-homedir-pathname) "cl/asdf/uiop/contrib/debug.lisp"))
     "form that evaluates to the pathname to your favorite debugging utilities")
 
-  (defmacro asdf-debug (&rest keys)
+  (defmacro uiop-debug (&rest keys)
     `(eval-when (:compile-toplevel :load-toplevel :execute)
-       (load-asdf-debug-utility ,@keys)))
+       (load-uiop-debug-utility ,@keys)))
 
-  (defun load-asdf-debug-utility (&key package utility-file)
+  (defun load-uiop-debug-utility (&key package utility-file)
     (let* ((*package* (if package (find-package package) *package*))
            (keyword (read-from-string
                      (format nil ":DBG-~:@(~A~)" (package-name *package*)))))
       (unless (member keyword *features*)
-        (let* ((utility-file (or utility-file *asdf-debug-utility*))
+        (let* ((utility-file (or utility-file *uiop-debug-utility*))
                (file (ignore-errors (probe-file (eval utility-file)))))
           (if file (load file)
               (error "Failed to locate debug utility file: ~S" utility-file)))))))
diff --git a/upgrade.lisp b/upgrade.lisp
index 63b6b53e9c0bc3bd18d27f13b500e0b4ddade318..a9511756559fdf3d1e426587bd28c197b4901c59 100644
--- a/upgrade.lisp
+++ b/upgrade.lisp
@@ -52,7 +52,7 @@ You can compare this string with e.g.: (ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSIO
          ;; "3.4.5.67" would be a development version in the official upstream of 3.4.5.
          ;; "3.4.5.0.8" would be your eighth local modification of official release 3.4.5
          ;; "3.4.5.67.8" would be your eighth local modification of development version 3.4.5.67
-         (asdf-version "2.32.2")
+         (asdf-version "2.32.6")
          (existing-version (asdf-version)))
     (setf *asdf-version* asdf-version)
     (when (and existing-version (not (equal asdf-version existing-version)))
@@ -89,7 +89,8 @@ You can compare this string with e.g.: (ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSIO
     (loop :for name :in (append redefined-functions)
           :for sym = (find-symbol* name :asdf nil) :do
             (when sym
-              (fmakunbound sym)))
+              ;; On CLISP we seem to be unable to fmakunbound and define a function in the same fasl. Sigh.
+              #-clisp (fmakunbound sym)))
     (loop :with asdf = (find-package :asdf)
           :for name :in uninterned-symbols
           :for sym = (find-symbol* name :asdf nil)
diff --git a/version.lisp-expr b/version.lisp-expr
index 26a6c8cf83b3ac50b982f07b5675feffef64a8b7..1835bc78b5045e00a23f03331a4c87803c56e3b7 100644
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -1 +1 @@
-"2.32.2"
+"2.32.6"