--- a/lisp/update-elc-2.el.orig	2022-06-16 21:58:48.748641021 +0200
+++ b/lisp/update-elc-2.el	2022-06-16 21:58:48.748641021 +0200
@@ -137,37 +137,10 @@
   (let ((dir (car command-line-args-left)))
     ;; don't depend on being able to autoload `update-autoload-files'!
     (load "autoload")
-    (autoload 'cl-compile-time-init "cl-macs")
     (load "bytecomp")
     (load "byte-optimize")
-    ;; #### the API used here is deprecated, convert to one with explicit
-    ;; arguments when it is available
-    ;; update-elc.el signals us to rebuild the autoloads when necessary.
-    ;; in some cases it will rebuild the autoloads itself, but doing it this
-    ;; way is slow, so we avoid it when possible.
-    (when (file-exists-p (expand-file-name "REBUILD_AUTOLOADS"
-					   invocation-directory))
-      ;; if we were instructed to rebuild the autoloads, force the file
-      ;; to be touched even w/o changes; otherwise, we won't ever stop
-      ;; being told to rebuild them.
-      (update-autoload-files dir "auto" nil t)
-      (byte-recompile-file (expand-file-name "auto-autoloads.el" dir) 0)
-      (when (featurep 'mule)
-	(let ((muledir (expand-file-name "../lisp/mule" (file-truename dir))))
-	  ;; force here just like above.
-	  (update-autoload-files muledir "mule" nil t)
-	  (byte-recompile-file (expand-file-name "auto-autoloads.el" dir) 0))))
-    (when (featurep 'modules)
-      (let* ((moddir (expand-file-name "../modules" (file-truename dir)))
-	     (autofile (expand-file-name "auto-autoloads.el" moddir)))
-	(update-autoload-files 
-	 (delete (concat (file-name-as-directory moddir) ".")
-		 (delete (concat (file-name-as-directory moddir) "..")
-			 (directory-files moddir t nil nil 0)))
-	 "modules" autofile)
-	(byte-recompile-file autofile 0)))
-    ;; now load the (perhaps newly rebuilt) autoloads; we were called with
-    ;; -no-autoloads so they're not already loaded.
+    ;; now load the autoloads; we were called with -no-autoloads so they're not
+    ;; already loaded.
     (load (expand-file-name "auto-autoloads" lisp-directory))
     (when (featurep 'mule)
       (load (expand-file-name "mule/auto-autoloads" lisp-directory)))
@@ -175,6 +148,8 @@
     ;; there may be dependencies between one .el and another (even across
     ;; directories), and we don't want to load an out-of-date .elc while
     ;; byte-compiling a file.
+    (when (featurep 'modules)
+      (load (expand-file-name "auto-autoloads" module-directory)))
     (message "Removing old or spurious .elcs in directory tree `%s'..." dir)
     (do-update-elc-2 dir nil nil)
     (message "Removing old or spurious .elcs in directory tree `%s'...done"
--- a/lisp/update-elc.el.orig	2022-06-16 21:58:48.748641021 +0200
+++ b/lisp/update-elc.el	2022-06-16 21:58:48.748641021 +0200
@@ -54,8 +54,11 @@
 (defvar update-elc-files-to-compile nil)
 (defvar need-to-rebuild-autoloads nil)
 (defvar need-to-rebuild-mule-autoloads nil)
+(defvar need-to-rebuild-module-autoloads nil)
 (defvar need-to-recompile-autoloads nil)
 (defvar need-to-recompile-mule-autoloads nil)
+(defvar need-to-recompile-module-autoloads nil)
+
 (defvar exe-target nil)
 (defvar dump-target nil)
 (defvar dump-target-out-of-date-wrt-dump-files nil)
@@ -84,10 +87,14 @@
 
 (defvar source-lisp-mule (expand-file-name "mule" source-lisp))
 (defvar source-directory (expand-file-name ".." source-lisp))
+(defconst module-directory (expand-file-name "modules" source-directory))
+
 (defvar aa-lisp (expand-file-name "auto-autoloads.el" source-lisp))
 (defvar aac-lisp (expand-file-name "auto-autoloads.elc" source-lisp))
 (defvar aa-lisp-mule (expand-file-name "auto-autoloads.el" source-lisp-mule))
 (defvar aac-lisp-mule (expand-file-name "auto-autoloads.elc" source-lisp-mule))
+(defvar aa-modules (expand-file-name "auto-autoloads.el" module-directory))
+(defvar aac-modules (expand-file-name "auto-autoloads.elc" module-directory))
 
 (setq load-path (list source-lisp))
 
@@ -130,7 +137,8 @@
 
 (defvar lisp-files-ignored-when-checking-for-autoload-updating
   '("custom-load.el"
-    "auto-autoloads.el")
+    "auto-autoloads.el"
+    "finder-inf.el")
   "Lisp files that should not trigger auto-autoloads rebuilding.")
 
 (defun update-elc-chop-extension (file)
@@ -270,6 +278,18 @@
 	  (setq all-files-in-dir (cdr all-files-in-dir))))
       (setq dirs-to-check (cdr dirs-to-check))))
 
+  ;; Check for the module autoloads separately, given the need to run
+  ;; directory-files on subdirectories.
+  (let ((autoload-file
+        (expand-file-name "auto-autoloads.el" module-directory)))
+    (mapc
+     #'(lambda (full-dir)
+        (mapc #'(lambda (full-arg)
+                  (when (file-newer-than-file-p full-arg autoload-file)
+                    (setq need-to-rebuild-module-autoloads t)))
+              (directory-files full-dir t "\\.c$" nil t)))
+     (directory-files module-directory t nil t 'subdirs)))
+
   (if dump-target-out-of-date-wrt-dump-files
       (condition-case nil
 	  (write-region-internal
@@ -297,6 +317,14 @@
 	  (file-newer-than-file-p aa-lisp-mule aac-lisp-mule))
   (setq need-to-recompile-mule-autoloads t))
 
+(when (or need-to-rebuild-module-autoloads
+         ;; not necessary but ...  see comment above.
+         (eq (file-exists-p aa-modules) nil)
+         ;; no need to check for file-exists of .elc due to definition
+         ;; of file-newer-than-file-p
+         (file-newer-than-file-p aa-modules aac-modules))
+  (setq need-to-recompile-module-autoloads t))
+
 (when (not (featurep 'mule))
   ;; sorry charlie.
   (setq need-to-rebuild-mule-autoloads nil
@@ -318,15 +346,18 @@
 	(if need-to-rebuild-mule-autoloads
 	    (list "-f" "batch-update-directory-autoloads"
 		  "mule" source-lisp-mule))
+        (if need-to-rebuild-module-autoloads
+            (list "-f" "batch-update-directory-autoloads"
+                  "auto" module-directory))
 	(if need-to-recompile-autoloads
 	    (list "-f" "batch-byte-compile-one-file"
 		  aa-lisp))
 	(if need-to-recompile-mule-autoloads
 	    (list "-f" "batch-byte-compile-one-file"
-		  aa-lisp-mule)))))
-  (condition-case nil
-      (delete-file (expand-file-name "src/REBUILD_AUTOLOADS" build-directory))
-    (file-error nil))
+                  aa-lisp-mule))
+        (if need-to-recompile-module-autoloads
+            (list "-f" "batch-byte-compile-one-file"
+                  aa-modules)))))
   (cond ((and (not update-elc-files-to-compile)
 	      (not need-to-rebuild-autoloads)
 	      (not need-to-rebuild-mule-autoloads)
@@ -335,17 +366,25 @@
 	 ;; (1) Nothing to do at all.
 	 )
 	((not update-elc-files-to-compile)
-	 ;; (2) We have no files to byte-compile, but we do need to
-	 ;;     regenerate and compile the auto-autoloads file, so signal
-	 ;;     update-elc-2 to do it.  This is much faster than loading
-	 ;;     all the .el's and doing it here. (We only need to rebuild
-	 ;;     the autoloads here when we have files to compile, since
-	 ;;     they may depend on the updated autoloads.)
-	 (condition-case nil
-	     (write-region-internal
-	      "foo" nil (expand-file-name "src/REBUILD_AUTOLOADS" build-directory))
-	   (file-error nil))
-	 )
+         ;; (2) We have no files to byte-compile, but we do need to regenerate
+         ;;     and compile the auto-autoloads file. Don't pass this on to
+         ;;     update-elc-2.el to do, since that gives dependency problems
+         ;;     with parallel builds (make -j and friends). Completely fine to
+         ;;     use the compiled Lisp infrastructure for this, though, since we
+         ;;     know it's up to date.
+         (setq command-line-args
+               (append
+                '("-l" "loadup-el.el" "run-temacs"
+                  "-batch" "-no-packages" "-no-autoloads"
+                  "-eval" "(setq stack-trace-on-error t)"
+                  "-eval" "(setq load-always-display-messages t)"
+                  "-l" "bytecomp.elc" "-l" "autoload.elc")
+                do-autoload-commands))
+         (write-sequence "\nNeed to regenerate auto-autoload files... "
+                         'external-debugging-output)
+         (let ((load-ignore-elc-files nil)
+               (purify-flag nil))
+           (load "loadup.el")))
 	(t
 	 (let ((bc-bootstrap
 		(mapcar #'(lambda (arg) 
