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.

1 files changed, 12 insertions, 15 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;