1 files changed, 86 insertions, 5 deletions

diff --git a/src/bytecode.c b/src/bytecode.c
index 29b76f88ef7..fe59cf6600b 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -311,8 +311,6 @@ enum byte_code_op
 
 #define TOP (*top)
 
-#define UPDATE_OFFSET (backtrace_byte_offset = pc - bytestr_data);
-
 DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, 3, 0,
        doc: /* Function used internally in byte-compiled code.
 The first argument, BYTESTR, is a string of byte code;
@@ -433,7 +431,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
       /* NEXT is invoked at the end of an instruction to go to the
          next instruction.  It is either a computed goto, or a
          plain break.  */
-#define NEXT UPDATE_OFFSET goto *(targets[op = FETCH])
+#define NEXT goto *(targets[op = FETCH])
       /* FIRST is like NEXT, but is only used at the start of the
          interpreter body.  In the switch-based interpreter it is the
          switch, so the threaded definition must include a semicolon.  */
@@ -635,7 +633,90 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
                   }
               }
 #endif
-            TOP = Ffuncall (op + 1, &TOP);
+            Lisp_Object fun, original_fun;
+            Lisp_Object funcar;
+            Lisp_Object *fun_args;
+            ptrdiff_t numargs = op;
+            Lisp_Object val;
+            ptrdiff_t count_c;
+
+            maybe_quit ();
+
+            if (++lisp_eval_depth > max_lisp_eval_depth)
+              {
+                if (max_lisp_eval_depth < 100)
+                  max_lisp_eval_depth = 100;
+                if (lisp_eval_depth > max_lisp_eval_depth)
+                  error ("Lisp nesting exceeds `max-lisp-eval-depth'");
+              }
+
+            fun_args = &TOP + 1;
+
+            count_c = record_in_backtrace_with_offset (TOP, fun_args, numargs, pc - bytestr_data - 1);
+
+            maybe_gc ();
+
+            if (debug_on_next_call)
+              do_debug_on_call (Qlambda, count);
+
+            original_fun = TOP;
+
+          retry:
+
+            /* Optimize for no indirection.  */
+            fun = original_fun;
+            if (SYMBOLP (fun) && !NILP (fun)
+                && (fun = XSYMBOL (fun)->u.s.function, SYMBOLP (fun)))
+              fun = indirect_function (fun);
+
+            if (COMPILEDP (fun))
+              {
+                Lisp_Object syms_left = AREF (fun, COMPILED_ARGLIST);
+                if (FIXNUMP (syms_left))
+                  {
+                    if (CONSP (AREF (fun, COMPILED_BYTECODE)))
+                      Ffetch_bytecode (fun);
+                    val = exec_byte_code (AREF (fun, COMPILED_BYTECODE),
+                                          AREF (fun, COMPILED_CONSTANTS),
+                                          AREF (fun, COMPILED_STACK_DEPTH),
+                                          syms_left, numargs, fun_args);
+                  }
+                else
+                  {
+                    /* The rest of funcall_lambda is very bulky */
+                    val = funcall_lambda (fun, numargs, fun_args);
+                  }
+              }
+            else if (SUBRP (fun))
+              val = funcall_subr (XSUBR (fun), numargs, fun_args);
+#ifdef HAVE_MODULES
+            else if (MODULE_FUNCTIONP (fun))
+              val = funcall_module (fun, numargs, fun_args);
+#endif
+            else
+              {
+                if (NILP (fun))
+                  xsignal1 (Qvoid_function, original_fun);
+                if (!CONSP (fun)
+                    || (funcar = XCAR (fun), !SYMBOLP(funcar)))
+                  xsignal1 (Qinvalid_function, original_fun);
+                if (EQ (funcar, Qlambda)
+                    || EQ (funcar, Qclosure))
+                  val = funcall_lambda (fun, numargs, fun_args);
+                else if (EQ (funcar, Qautoload))
+                  {
+                    Fautoload_do_load (fun, original_fun, Qnil);
+                    goto retry;
+                  }
+                else
+                  xsignal1 (Qinvalid_function, original_fun);
+              }
+            lisp_eval_depth--;
+            if (backtrace_debug_on_exit (specpdl + count_c))
+              val = call_debugger (list2 (Qexit, val));
+            specpdl_ptr--;
+
+            TOP = val;
             NEXT;
           }
 
@@ -1451,7 +1532,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
         unbind_to (count, Qnil);
       error ("binding stack not balanced (serious byte compiler bug)");
     }
-  backtrace_byte_offset = -1;
+
   Lisp_Object result = TOP;
   SAFE_FREE ();
   return result;