Merge remote-tracking branch 'savannah/master' into HEAD

9 files changed, 173 insertions, 106 deletions

diff --git a/src/alloc.c b/src/alloc.c
index d6ba4d97905..76d49d2efd6 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -3429,23 +3429,6 @@ usage: (vector &rest OBJECTS)  */)
   return val;
 }
 
-void
-make_byte_code (struct Lisp_Vector *v)
-{
-  /* Don't allow the global zero_vector to become a byte code object.  */
-  eassert (0 < v->header.size);
-
-  if (v->header.size > 1 && STRINGP (v->contents[1])
-      && STRING_MULTIBYTE (v->contents[1]))
-    /* BYTECODE-STRING must have been produced by Emacs 20.2 or the
-       earlier because they produced a raw 8-bit string for byte-code
-       and now such a byte-code string is loaded as multibyte while
-       raw 8-bit characters converted to multibyte form.  Thus, now we
-       must convert them back to the original unibyte form.  */
-    v->contents[1] = Fstring_as_unibyte (v->contents[1]);
-  XSETPVECTYPE (v, PVEC_COMPILED);
-}
-
 DEFUN ("make-byte-code", Fmake_byte_code, Smake_byte_code, 4, MANY, 0,
        doc: /* Create a byte-code object with specified arguments as elements.
 The arguments should be the ARGLIST, bytecode-string BYTE-CODE, constant
@@ -3464,8 +3447,14 @@ stack before executing the byte-code.
 usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  Lisp_Object val = make_uninit_vector (nargs);
-  struct Lisp_Vector *p = XVECTOR (val);
+  if (! ((FIXNUMP (args[COMPILED_ARGLIST])
+          || CONSP (args[COMPILED_ARGLIST])
+          || NILP (args[COMPILED_ARGLIST]))
+         && STRINGP (args[COMPILED_BYTECODE])
+         && !STRING_MULTIBYTE (args[COMPILED_BYTECODE])
+         && VECTORP (args[COMPILED_CONSTANTS])
+         && FIXNATP (args[COMPILED_STACK_DEPTH])))
+    error ("Invalid byte-code object");
 
   /* We used to purecopy everything here, if purify-flag was set.  This worked
      OK for Emacs-23, but with Emacs-24's lexical binding code, it can be
@@ -3474,10 +3463,8 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
      copied into pure space, including its free variables, which is sometimes
      just wasteful and other times plainly wrong (e.g. those free vars may want
      to be setcar'd).  */
-
-  memcpy (p->contents, args, nargs * sizeof *args);
-  make_byte_code (p);
-  XSETCOMPILED (val, p);
+  Lisp_Object val = Fvector (nargs, args);
+  XSETPVECTYPE (XVECTOR (val), PVEC_COMPILED);
   return val;
 }
 
@@ -5019,8 +5006,9 @@ mark_stack (char const *bottom, char const *end)
 #endif
 }
 
-/* This is a trampoline function that flushes registers to the stack,
-   and then calls FUNC.  ARG is passed through to FUNC verbatim.
+/* flush_stack_call_func is the trampoline function that flushes
+   registers to the stack, and then calls FUNC.  ARG is passed through
+   to FUNC verbatim.
 
    This function must be called whenever Emacs is about to release the
    global interpreter lock.  This lets the garbage collector easily
@@ -5028,7 +5016,20 @@ mark_stack (char const *bottom, char const *end)
    Lisp.
 
    It is invalid to run any Lisp code or to allocate any GC memory
-   from FUNC.  */
+   from FUNC.
+
+   Note: all register spilling is done in flush_stack_call_func before
+   flush_stack_call_func1 is activated.
+
+   flush_stack_call_func1 is responsible for identifying the stack
+   address range to be scanned.  It *must* be carefully kept as
+   noinline to make sure that registers has been spilled before it is
+   called, otherwise given __builtin_frame_address (0) typically
+   returns the frame pointer (base pointer) and not the stack pointer
+   [1] GC will miss to scan callee-saved registers content
+   (Bug#41357).
+
+   [1] <https://gcc.gnu.org/onlinedocs/gcc/Return-Address.html>.  */
 
 NO_INLINE void
 flush_stack_call_func1 (void (*func) (void *arg), void *arg)
diff --git a/src/buffer.c b/src/buffer.c
index 53b3bd960c4..f1cb4d50414 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -119,6 +119,7 @@ static void free_buffer_text (struct buffer *b);
 static struct Lisp_Overlay * copy_overlays (struct buffer *, struct Lisp_Overlay *);
 static void modify_overlay (struct buffer *, ptrdiff_t, ptrdiff_t);
 static Lisp_Object buffer_lisp_local_variables (struct buffer *, bool);
+static Lisp_Object buffer_local_variables_1 (struct buffer *buf, int offset, Lisp_Object sym);
 
 static void
 CHECK_OVERLAY (Lisp_Object x)
@@ -1300,6 +1301,25 @@ buffer_lisp_local_variables (struct buffer *buf, bool clone)
   return result;
 }
 
+
+/* If the variable at position index OFFSET in buffer BUF has a
+   buffer-local value, return (name . value).  If SYM is non-nil,
+   it replaces name.  */
+
+static Lisp_Object
+buffer_local_variables_1 (struct buffer *buf, int offset, Lisp_Object sym)
+{
+  int idx = PER_BUFFER_IDX (offset);
+  if ((idx == -1 || PER_BUFFER_VALUE_P (buf, idx))
+      && SYMBOLP (PER_BUFFER_SYMBOL (offset)))
+    {
+      sym = NILP (sym) ? PER_BUFFER_SYMBOL (offset) : sym;
+      Lisp_Object val = per_buffer_value (buf, offset);
+      return EQ (val, Qunbound) ? sym : Fcons (sym, val);
+    }
+  return Qnil;
+}
+
 DEFUN ("buffer-local-variables", Fbuffer_local_variables,
        Sbuffer_local_variables, 0, 1, 0,
        doc: /* Return an alist of variables that are buffer-local in BUFFER.
@@ -1311,25 +1331,25 @@ No argument or nil as argument means use current buffer as BUFFER.  */)
 {
   struct buffer *buf = decode_buffer (buffer);
   Lisp_Object result = buffer_lisp_local_variables (buf, 0);
+  Lisp_Object tem;
 
   /* Add on all the variables stored in special slots.  */
   {
-    int offset, idx;
+    int offset;
 
     FOR_EACH_PER_BUFFER_OBJECT_AT (offset)
       {
-        idx = PER_BUFFER_IDX (offset);
-        if ((idx == -1 || PER_BUFFER_VALUE_P (buf, idx))
-            && SYMBOLP (PER_BUFFER_SYMBOL (offset)))
-          {
-            Lisp_Object sym = PER_BUFFER_SYMBOL (offset);
-            Lisp_Object val = per_buffer_value (buf, offset);
-            result = Fcons (EQ (val, Qunbound) ? sym : Fcons (sym, val),
-                            result);
-          }
+        tem = buffer_local_variables_1 (buf, offset, Qnil);
+        if (!NILP (tem))
+          result = Fcons (tem, result);
       }
   }
 
+  tem = buffer_local_variables_1 (buf, PER_BUFFER_VAR_OFFSET (undo_list),
+                                  intern ("buffer-undo-list"));
+  if (!NILP (tem))
+    result = Fcons (tem, result);
+
   return result;
 }
 
diff --git a/src/bytecode.c b/src/bytecode.c
index 3c90544f3f2..5ac30aa1010 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -319,6 +319,19 @@ the third, MAXDEPTH, the maximum stack depth used in this function.
 If the third argument is incorrect, Emacs may crash.  */)
   (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth)
 {
+  if (! (STRINGP (bytestr) && VECTORP (vector) && FIXNATP (maxdepth)))
+    error ("Invalid byte-code");
+
+  if (STRING_MULTIBYTE (bytestr))
+    {
+      /* 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.  */
+      bytestr = Fstring_as_unibyte (bytestr);
+    }
+
   return exec_byte_code (bytestr, vector, maxdepth, Qnil, 0, NULL);
 }
 
@@ -344,21 +357,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   int volatile this_op = 0;
 #endif
 
-  CHECK_STRING (bytestr);
-  CHECK_VECTOR (vector);
-  CHECK_FIXNAT (maxdepth);
+  eassert (!STRING_MULTIBYTE (bytestr));
 
   ptrdiff_t const_length = ASIZE (vector);
-
-  if (STRING_MULTIBYTE (bytestr))
-    /* BYTESTR must have been produced by Emacs 20.2 or the earlier
-       because they produced a raw 8-bit string for byte-code and now
-       such a byte-code string is loaded as multibyte while raw 8-bit
-       characters converted to multibyte form.  Thus, now we must
-       convert them back to the originally intended unibyte form.  */
-    bytestr = Fstring_as_unibyte (bytestr);
-
-  ptrdiff_t bytestr_length = SBYTES (bytestr);
+  ptrdiff_t bytestr_length = SCHARS (bytestr);
   Lisp_Object *vectorp = XVECTOR (vector)->contents;
 
   unsigned char quitcounter = 1;
diff --git a/src/emacs.c b/src/emacs.c
index e75cb588349..93a837a44ef 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -124,6 +124,11 @@ static const char emacs_version[] = PACKAGE_VERSION;
 static const char emacs_copyright[] = COPYRIGHT;
 static const char emacs_bugreport[] = PACKAGE_BUGREPORT;
 
+/* Put version info into the executable in the form that 'ident' uses.  */
+char const EXTERNALLY_VISIBLE RCS_Id[]
+  = "$Id" ": GNU Emacs " PACKAGE_VERSION
+    " (" EMACS_CONFIGURATION " " EMACS_CONFIG_FEATURES ") $";
+
 /* Empty lisp strings.  To avoid having to build any others.  */
 Lisp_Object empty_unibyte_string, empty_multibyte_string;
 
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));
         }
     }
diff --git a/src/fns.c b/src/fns.c
index 301bd59ab90..b2f84b202de 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2508,26 +2508,36 @@ ARRAY is a vector, string, char-table, or bool-vector.  */)
     }
   else if (STRINGP (array))
     {
-      register unsigned char *p = SDATA (array);
-      int charval;
+      unsigned char *p = SDATA (array);
       CHECK_CHARACTER (item);
-      charval = XFIXNAT (item);
+      int charval = XFIXNAT (item);
       size = SCHARS (array);
-      if (STRING_MULTIBYTE (array))
+      if (size != 0)
         {
+          CHECK_IMPURE (array, XSTRING (array));
           unsigned char str[MAX_MULTIBYTE_LENGTH];
-          int len = CHAR_STRING (charval, str);
-          ptrdiff_t size_byte = SBYTES (array);
-          ptrdiff_t product;
+          int len;
+          if (STRING_MULTIBYTE (array))
+            len = CHAR_STRING (charval, str);
+          else
+            {
+              str[0] = charval;
+              len = 1;
+            }
 
-          if (INT_MULTIPLY_WRAPV (size, len, &product) || product != size_byte)
-            error ("Attempt to change byte length of a string");
-          for (idx = 0; idx < size_byte; idx++)
-            *p++ = str[idx % len];
+          ptrdiff_t size_byte = SBYTES (array);
+          if (len == 1 && size == size_byte)
+            memset (p, str[0], size);
+          else
+            {
+              ptrdiff_t product;
+              if (INT_MULTIPLY_WRAPV (size, len, &product)
+                  || product != size_byte)
+                error ("Attempt to change byte length of a string");
+              for (idx = 0; idx < size_byte; idx++)
+                *p++ = str[idx % len];
+            }
         }
-      else
-        for (idx = 0; idx < size; idx++)
-          p[idx] = charval;
     }
   else if (BOOL_VECTOR_P (array))
     return bool_vector_fill (array, item);
@@ -2542,12 +2552,15 @@ DEFUN ("clear-string", Fclear_string, Sclear_string,
 This makes STRING unibyte and may change its length.  */)
   (Lisp_Object string)
 {
-  ptrdiff_t len;
   CHECK_STRING (string);
-  len = SBYTES (string);
-  memset (SDATA (string), 0, len);
-  STRING_SET_CHARS (string, len);
-  STRING_SET_UNIBYTE (string);
+  ptrdiff_t len = SBYTES (string);
+  if (len != 0 || STRING_MULTIBYTE (string))
+    {
+      CHECK_IMPURE (string, XSTRING (string));
+      memset (SDATA (string), 0, len);
+      STRING_SET_CHARS (string, len);
+      STRING_SET_UNIBYTE (string);
+    }
   return Qnil;
 }
 
diff --git a/src/lisp.h b/src/lisp.h
index 9e4d53ccf17..4c0057b2552 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1343,7 +1343,6 @@ dead_object (void)
 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
-#define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
@@ -3943,7 +3942,6 @@ build_string (const char *str)
 
 extern Lisp_Object pure_cons (Lisp_Object, Lisp_Object);
 extern Lisp_Object make_vector (ptrdiff_t, Lisp_Object);
-extern void make_byte_code (struct Lisp_Vector *);
 extern struct Lisp_Vector *allocate_vector (ptrdiff_t);
 extern struct Lisp_Vector *allocate_nil_vector (ptrdiff_t);
 
diff --git a/src/lread.c b/src/lread.c
index 01f359ca581..46725d9b0ff 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -3030,8 +3030,26 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
           struct Lisp_Vector *vec;
           tmp = read_vector (readcharfun, 1);
           vec = XVECTOR (tmp);
-          if (vec->header.size == 0)
-            invalid_syntax ("Empty byte-code object");
+          if (! (COMPILED_STACK_DEPTH < vec->header.size
+                 && (FIXNUMP (vec->contents[COMPILED_ARGLIST])
+                     || CONSP (vec->contents[COMPILED_ARGLIST])
+                     || NILP (vec->contents[COMPILED_ARGLIST]))
+                 && ((STRINGP (vec->contents[COMPILED_BYTECODE])
+                      && VECTORP (vec->contents[COMPILED_CONSTANTS]))
+                     || CONSP (vec->contents[COMPILED_BYTECODE]))
+                 && FIXNATP (vec->contents[COMPILED_STACK_DEPTH])))
+            invalid_syntax ("Invalid byte-code object");
+
+          if (STRING_MULTIBYTE (AREF (tmp, 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.  */
+              ASET (tmp, COMPILED_BYTECODE,
+                    Fstring_as_unibyte (AREF (tmp, COMPILED_BYTECODE)));
+            }
 
           if (COMPILED_DOC_STRING < vec->header.size
               && EQ (AREF (tmp, COMPILED_DOC_STRING), make_fixnum (0)))
@@ -3050,7 +3068,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
               ASET (tmp, COMPILED_DOC_STRING, make_ufixnum (hash));
             }
 
-          make_byte_code (vec);
+          XSETPVECTYPE (vec, PVEC_COMPILED);
           return tmp;
         }
       if (c == '(')
@@ -3888,8 +3906,6 @@ read_vector (Lisp_Object readcharfun, bool bytecodeflag)
 {
   Lisp_Object tem = read_list (1, readcharfun);
   ptrdiff_t size = list_length (tem);
-  if (bytecodeflag && size <= COMPILED_STACK_DEPTH)
-    error ("Invalid byte code");
   Lisp_Object vector = make_nil_vector (size);
 
   Lisp_Object *ptr = XVECTOR (vector)->contents;
diff --git a/src/w32.c b/src/w32.c
index d01a45029d8..38bbc496563 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -6519,7 +6519,15 @@ acl_get_file (const char *fname, acl_type_t type)
               if (!get_file_security (fname, si, psd, sd_len, &sd_len))
                 {
                   xfree (psd);
-                  errno = EIO;
+                  err = GetLastError ();
+                  if (err == ERROR_NOT_SUPPORTED)
+                    errno = ENOTSUP;
+                  else if (err == ERROR_FILE_NOT_FOUND
+                           || err == ERROR_PATH_NOT_FOUND
+                           || err == ERROR_INVALID_NAME)
+                    errno = ENOENT;
+                  else
+                    errno = EIO;
                   psd = NULL;
                 }
             }
@@ -6530,6 +6538,8 @@ acl_get_file (const char *fname, acl_type_t type)
                       be encoded in the current ANSI codepage. */
                    || err == ERROR_INVALID_NAME)
             errno = ENOENT;
+          else if (err == ERROR_NOT_SUPPORTED)
+            errno = ENOTSUP;
           else
             errno = EIO;
         }