Eliminate lazy bytecode loading

The obsolete lazy-loaded bytecode feature, enabled by
`byte-compile-dynamic`, slows down Lisp execution even when not in use
because every call to a bytecode function has to check that function
for laziness.

This change forces up-front loading of all lazy bytecode so that we
can remove all those checks.  (Dynamically loaded doc strings are not
affected.)

There is no point in generating lazy bytecode any more so we stop
doing that; this simplifies the compiler.  `byte-compile-dynamic` now
has no effect.

This is a fully compatible change; the few remaining users of
`byte-compile-dynamic` should not notice any difference.

* src/lread.c (bytecode_from_rev_list): Force eager loading of
lazy bytecode.
* src/bytecode.c (exec_byte_code): Remove lazy bytecode checks.
* src/eval.c (fetch_and_exec_byte_code, Ffetch_bytecode): Remove.
(funcall_lambda): Call exec_byte_code directly, avoiding checks.
* lisp/subr.el (fetch-bytecode): New definition, obsolete no-op.
* lisp/emacs-lisp/disass.el (disassemble-1):
* lisp/emacs-lisp/bytecomp.el (byte-compile-unfold-bcf):
Remove calls to fetch-bytecode.
(byte-compile-dynamic): Update doc string.
(byte-compile-close-variables, byte-compile-from-buffer)
(byte-compile-insert-header, byte-compile-output-file-form)
(byte-compile--output-docform-recurse, byte-compile-output-docform)
(byte-compile-file-form-defmumble):
Remove effects of byte-compile-dynamic.
* doc/lispref/compile.texi (Dynamic Loading): Remove node now that
the entire `byte-compile-dynamic` facility has been rendered inert.
* etc/NEWS: Announce changes.

3 files changed, 39 insertions, 96 deletions

diff --git a/src/bytecode.c b/src/bytecode.c
index ed6e2b34e77..def20b232c6 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -792,22 +792,19 @@ exec_byte_code (Lisp_Object fun, ptrdiff_t args_template,
             Lisp_Object original_fun = call_fun;
             if (SYMBOLP (call_fun))
               call_fun = XSYMBOL (call_fun)->u.s.function;
-            Lisp_Object template;
-            Lisp_Object bytecode;
-            if (COMPILEDP (call_fun)
-                /* Lexical binding only.  */
-                && (template = AREF (call_fun, COMPILED_ARGLIST),
-                    FIXNUMP (template))
-                /* No autoloads.  */
-                && (bytecode = AREF (call_fun, COMPILED_BYTECODE),
-                    !CONSP (bytecode)))
+            if (COMPILEDP (call_fun))
               {
-                fun = call_fun;
-                bytestr = bytecode;
-                args_template = XFIXNUM (template);
-                nargs = call_nargs;
-                args = call_args;
-                goto setup_frame;
+                Lisp_Object template = AREF (call_fun, COMPILED_ARGLIST);
+                if (FIXNUMP (template))
+                  {
+                    /* Fast path for lexbound functions.  */
+                    fun = call_fun;
+                    bytestr = AREF (call_fun, COMPILED_BYTECODE),
+                    args_template = XFIXNUM (template);
+                    nargs = call_nargs;
+                    args = call_args;
+                    goto setup_frame;
+                  }
               }
 
             Lisp_Object val;
diff --git a/src/eval.c b/src/eval.c
index 6f1c39ffb0e..95eb21909d2 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -3122,19 +3122,6 @@ funcall_subr (struct Lisp_Subr *subr, ptrdiff_t numargs, Lisp_Object *args)
     xsignal2 (Qwrong_number_of_arguments, fun, make_fixnum (numargs));
 }
 
-/* Call the compiled Lisp function FUN.  If we have not yet read FUN's
-   bytecode string and constants vector, fetch them from the file first.  */
-
-static Lisp_Object
-fetch_and_exec_byte_code (Lisp_Object fun, ptrdiff_t args_template,
-                          ptrdiff_t nargs, Lisp_Object *args)
-{
-  if (CONSP (AREF (fun, COMPILED_BYTECODE)))
-    Ffetch_bytecode (fun);
-
-  return exec_byte_code (fun, args_template, nargs, args);
-}
-
 static Lisp_Object
 apply_lambda (Lisp_Object fun, Lisp_Object args, specpdl_ref count)
 {
@@ -3204,8 +3191,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
          ARGLIST slot value: pass the arguments to the byte-code
          engine directly.  */
       if (FIXNUMP (syms_left))
-        return fetch_and_exec_byte_code (fun, XFIXNUM (syms_left),
-                                         nargs, arg_vector);
+        return exec_byte_code (fun, XFIXNUM (syms_left), nargs, arg_vector);
       /* Otherwise the bytecode object uses dynamic binding and the
          ARGLIST slot contains a standard formal argument list whose
          variables are bound dynamically below.  */
@@ -3293,7 +3279,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
       val = XSUBR (fun)->function.a0 ();
     }
   else
-    val = fetch_and_exec_byte_code (fun, 0, 0, NULL);
+    val = exec_byte_code (fun, 0, 0, NULL);
 
   return unbind_to (count, val);
 }
@@ -3411,46 +3397,6 @@ lambda_arity (Lisp_Object fun)
   return Fcons (make_fixnum (minargs), make_fixnum (maxargs));
 }
 
-DEFUN ("fetch-bytecode", Ffetch_bytecode, Sfetch_bytecode,
-       1, 1, 0,
-       doc: /* If byte-compiled OBJECT is lazy-loaded, fetch it now.  */)
-  (Lisp_Object object)
-{
-  Lisp_Object tem;
-
-  if (COMPILEDP (object))
-    {
-      if (CONSP (AREF (object, COMPILED_BYTECODE)))
-        {
-          tem = read_doc_string (AREF (object, COMPILED_BYTECODE));
-          if (! (CONSP (tem) && STRINGP (XCAR (tem))
-                 && VECTORP (XCDR (tem))))
-            {
-              tem = AREF (object, COMPILED_BYTECODE);
-              if (CONSP (tem) && STRINGP (XCAR (tem)))
-                error ("Invalid byte code in %s", SDATA (XCAR (tem)));
-              else
-                error ("Invalid byte code");
-            }
-
-          Lisp_Object bytecode = XCAR (tem);
-          if (STRING_MULTIBYTE (bytecode))
-            {
-              /* BYTECODE must have been produced by Emacs 20.2 or earlier
-                 because it produced a raw 8-bit string for byte-code and now
-                 such a byte-code string is loaded as multibyte with raw 8-bit
-                 characters converted to multibyte form.  Convert them back to
-                 the original unibyte form.  */
-              bytecode = Fstring_as_unibyte (bytecode);
-            }
-
-          pin_string (bytecode);
-          ASET (object, COMPILED_BYTECODE, bytecode);
-          ASET (object, COMPILED_CONSTANTS, XCDR (tem));
-        }
-    }
-  return object;
-}
 
 /* Return true if SYMBOL's default currently has a let-binding
    which was made in the buffer that is now current.  */
@@ -4512,7 +4458,6 @@ alist of active lexical bindings.  */);
   defsubr (&Srun_hook_with_args_until_success);
   defsubr (&Srun_hook_with_args_until_failure);
   defsubr (&Srun_hook_wrapped);
-  defsubr (&Sfetch_bytecode);
   defsubr (&Sbacktrace_debug);
   DEFSYM (QCdebug_on_exit, ":debug-on-exit");
   defsubr (&Smapbacktrace);
diff --git a/src/lread.c b/src/lread.c
index 929f86ef283..e77bfb8021d 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -3481,6 +3481,8 @@ vector_from_rev_list (Lisp_Object elems)
   return obj;
 }
 
+static Lisp_Object get_lazy_string (Lisp_Object val);
+
 static Lisp_Object
 bytecode_from_rev_list (Lisp_Object elems, Lisp_Object readcharfun)
 {
@@ -3495,14 +3497,18 @@ bytecode_from_rev_list (Lisp_Object elems, Lisp_Object readcharfun)
         && FIXNATP (vec[COMPILED_STACK_DEPTH])))
     invalid_syntax ("Invalid byte-code object", readcharfun);
 
-  if (load_force_doc_strings
-      && NILP (vec[COMPILED_CONSTANTS])
-      && STRINGP (vec[COMPILED_BYTECODE]))
+  /* Always read 'lazily-loaded' bytecode (generated by the
+     `byte-compile-dynamic' feature prior to Emacs 30) eagerly, to
+     avoid code in the fast path during execution.  */
+  if (CONSP (vec[COMPILED_BYTECODE]))
+    vec[COMPILED_BYTECODE] = get_lazy_string (vec[COMPILED_BYTECODE]);
+
+  /* Lazily-loaded bytecode is represented by the constant slot being nil
+     and the bytecode slot a (lazily loaded) string containing the
+     print representation of (BYTECODE . CONSTANTS).  Unpack the
+     pieces by coerceing the string to unibyte and reading the result.  */
+  if (NILP (vec[COMPILED_CONSTANTS]))
     {
-      /* Lazily-loaded bytecode is represented by the constant slot being nil
-         and the bytecode slot a (lazily loaded) string containing the
-         print representation of (BYTECODE . CONSTANTS).  Unpack the
-         pieces by coerceing the string to unibyte and reading the result.  */
       Lisp_Object enc = vec[COMPILED_BYTECODE];
       Lisp_Object pair = Fread (Fcons (enc, readcharfun));
       if (!CONSP (pair))
@@ -3512,25 +3518,20 @@ bytecode_from_rev_list (Lisp_Object elems, Lisp_Object readcharfun)
       vec[COMPILED_CONSTANTS] = XCDR (pair);
     }
 
-  if (!((STRINGP (vec[COMPILED_BYTECODE])
-         && VECTORP (vec[COMPILED_CONSTANTS]))
-        || CONSP (vec[COMPILED_BYTECODE])))
+  if (!(STRINGP (vec[COMPILED_BYTECODE])
+        && VECTORP (vec[COMPILED_CONSTANTS])))
     invalid_syntax ("Invalid byte-code object", readcharfun);
 
-  if (STRINGP (vec[COMPILED_BYTECODE]))
-    {
-      if (STRING_MULTIBYTE (vec[COMPILED_BYTECODE]))
-        {
-          /* BYTESTR must have been produced by Emacs 20.2 or earlier
-             because it produced a raw 8-bit string for byte-code and
-             now such a byte-code string is loaded as multibyte with
-             raw 8-bit characters converted to multibyte form.
-             Convert them back to the original unibyte form.  */
-          vec[COMPILED_BYTECODE] = Fstring_as_unibyte (vec[COMPILED_BYTECODE]);
-        }
-      /* Bytecode must be immovable.  */
-      pin_string (vec[COMPILED_BYTECODE]);
-    }
+  if (STRING_MULTIBYTE (vec[COMPILED_BYTECODE]))
+    /* BYTESTR must have been produced by Emacs 20.2 or earlier
+       because it produced a raw 8-bit string for byte-code and
+       now such a byte-code string is loaded as multibyte with
+       raw 8-bit characters converted to multibyte form.
+       Convert them back to the original unibyte form.  */
+    vec[COMPILED_BYTECODE] = Fstring_as_unibyte (vec[COMPILED_BYTECODE]);
+
+  /* Bytecode must be immovable.  */
+  pin_string (vec[COMPILED_BYTECODE]);
 
   XSETPVECTYPE (XVECTOR (obj), PVEC_COMPILED);
   return obj;