1 files changed, 32 insertions, 30 deletions

diff --git a/src/eval.c b/src/eval.c
index 1091b082552..37d466f69ed 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -2913,6 +2913,21 @@ funcall_subr (struct Lisp_Subr *subr, ptrdiff_t numargs, Lisp_Object *args)
     }
 }
 
+/* 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, Lisp_Object syms_left,
+                          ptrdiff_t nargs, Lisp_Object *args)
+{
+  if (CONSP (AREF (fun, COMPILED_BYTECODE)))
+    Ffetch_bytecode (fun);
+  return exec_byte_code (AREF (fun, COMPILED_BYTECODE),
+                         AREF (fun, COMPILED_CONSTANTS),
+                         AREF (fun, COMPILED_STACK_DEPTH),
+                         syms_left, nargs, args);
+}
+
 static Lisp_Object
 apply_lambda (Lisp_Object fun, Lisp_Object args, ptrdiff_t count)
 {
@@ -2977,9 +2992,6 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
     }
   else if (COMPILEDP (fun))
     {
-      ptrdiff_t size = PVSIZE (fun);
-      if (size <= COMPILED_STACK_DEPTH)
-        xsignal1 (Qinvalid_function, fun);
       syms_left = AREF (fun, COMPILED_ARGLIST);
       if (FIXNUMP (syms_left))
         /* A byte-code object with an integer args template means we
@@ -2991,15 +3003,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
            argument-binding code below instead (as do all interpreted
            functions, even lexically bound ones).  */
         {
-          /* If we have not actually read the bytecode string
-             and constants vector yet, fetch them from the file.  */
-          if (CONSP (AREF (fun, COMPILED_BYTECODE)))
-            Ffetch_bytecode (fun);
-          return exec_byte_code (AREF (fun, COMPILED_BYTECODE),
-                                 AREF (fun, COMPILED_CONSTANTS),
-                                 AREF (fun, COMPILED_STACK_DEPTH),
-                                 syms_left,
-                                 nargs, arg_vector);
+          return fetch_and_exec_byte_code (fun, syms_left, nargs, arg_vector);
         }
       lexenv = Qnil;
     }
@@ -3068,16 +3072,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
   if (CONSP (fun))
     val = Fprogn (XCDR (XCDR (fun)));
   else
-    {
-      /* If we have not actually read the bytecode string
-         and constants vector yet, fetch them from the file.  */
-      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),
-                            Qnil, 0, 0);
-    }
+    val = fetch_and_exec_byte_code (fun, Qnil, 0, NULL);
 
   return unbind_to (count, val);
 }
@@ -3162,9 +3157,6 @@ lambda_arity (Lisp_Object fun)
     }
   else if (COMPILEDP (fun))
     {
-      ptrdiff_t size = PVSIZE (fun);
-      if (size <= COMPILED_STACK_DEPTH)
-        xsignal1 (Qinvalid_function, fun);
       syms_left = AREF (fun, COMPILED_ARGLIST);
       if (FIXNUMP (syms_left))
         return get_byte_code_arity (syms_left);
@@ -3207,13 +3199,11 @@ DEFUN ("fetch-bytecode", Ffetch_bytecode, Sfetch_bytecode,
 
   if (COMPILEDP (object))
     {
-      ptrdiff_t size = PVSIZE (object);
-      if (size <= COMPILED_STACK_DEPTH)
-        xsignal1 (Qinvalid_function, object);
       if (CONSP (AREF (object, COMPILED_BYTECODE)))
         {
           tem = read_doc_string (AREF (object, COMPILED_BYTECODE));
-          if (!CONSP (tem))
+          if (! (CONSP (tem) && STRINGP (XCAR (tem))
+                 && VECTORP (XCDR (tem))))
             {
               tem = AREF (object, COMPILED_BYTECODE);
               if (CONSP (tem) && STRINGP (XCAR (tem)))
@@ -3221,7 +3211,19 @@ DEFUN ("fetch-bytecode", Ffetch_bytecode, Sfetch_bytecode,
               else
                 error ("Invalid byte code");
             }
-          ASET (object, COMPILED_BYTECODE, XCAR (tem));
+
+          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);
+            }
+
+          ASET (object, COMPILED_BYTECODE, bytecode);
           ASET (object, COMPILED_CONSTANTS, XCDR (tem));
         }
     }