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

16 files changed, 123 insertions, 51 deletions

diff --git a/src/Makefile.in b/src/Makefile.in
index 2f373d3eb7f..3cc9d594144 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -323,7 +323,7 @@ INTERVALS_H = dispextern.h intervals.h composite.h
 
 GETLOADAVG_LIBS = @GETLOADAVG_LIBS@
 
-LIB_GMP = @LIB_GMP@
+LIBGMP = @LIBGMP@
 
 LIBGCCJIT = @LIBGCCJIT_LIB@
 
@@ -535,7 +535,7 @@ LIBES = $(LIBS) $(W32_LIBS) $(LIBS_GNUSTEP) $(LIBX_BASE) $(LIBIMAGE) \
    $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(HARFBUZZ_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
    $(LIBGNUTLS_LIBS) $(LIB_PTHREAD) $(GETADDRINFO_A_LIBS) $(LCMS2_LIBS) \
    $(NOTIFY_LIBS) $(LIB_MATH) $(LIBZ) $(LIBMODULES) $(LIBSYSTEMD_LIBS) \
-   $(JSON_LIBS) $(LIB_GMP) $(LIBGCCJIT)
+   $(JSON_LIBS) $(LIBGMP) $(LIBGCCJIT)
 
 ## FORCE it so that admin/unidata can decide whether this file is
 ## up-to-date.  Although since charprop depends on bootstrap-emacs,
diff --git a/src/alloc.c b/src/alloc.c
index a31b4a045e2..12f53bdd6d8 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -1947,6 +1947,9 @@ resize_string_data (Lisp_Object string, ptrdiff_t cidx_byte,
       /* No need to reallocate, as the size change falls within the
          alignment slop.  */
       XSTRING (string)->u.s.size_byte = new_nbytes;
+#ifdef GC_CHECK_STRING_BYTES
+      SDATA_NBYTES (old_sdata) = new_nbytes;
+#endif
       new_charaddr = data + cidx_byte;
       memmove (new_charaddr + new_clen, new_charaddr + clen,
                nbytes - (cidx_byte + (clen - 1)));
@@ -4658,7 +4661,16 @@ mark_maybe_object (Lisp_Object obj)
       break;
     }
 
-  void *po = (char *) XLP (obj) + (offset - LISP_WORD_TAG (type_tag));
+  bool overflow
+    = INT_SUBTRACT_WRAPV (offset, LISP_WORD_TAG (type_tag), &offset);
+#if !defined WIDE_EMACS_INT || USE_LSB_TAG
+  /* If we don't use wide integers, then `intptr_t' should always be
+     large enough to not overflow.  Furthermore, when using the least
+     significant bits as tag bits, the tag is small enough to not
+     overflow either.  */
+  eassert (!overflow);
+#endif
+  void *po = (char *) ((intptr_t) (char *) XLP (obj) + offset);
 
   /* If the pointer is in the dump image and the dump has a record
      of the object starting at the place where the pointer points, we
@@ -4869,7 +4881,7 @@ mark_memory (void const *start, void const *end)
          On a host with 32-bit pointers and 64-bit Lisp_Objects,
          a Lisp_Object might be split into registers saved into
          non-adjacent words and P might be the low-order word's value.  */
-      p += (intptr_t) lispsym;
+      p = (char *) ((uintptr_t) p + (uintptr_t) lispsym);
       mark_maybe_pointer (p);
 
       verify (alignof (Lisp_Object) % GC_POINTER_ALIGNMENT == 0);
@@ -4986,27 +4998,6 @@ typedef union
 #endif
 } stacktop_sentry;
 
-/* Force callee-saved registers and register windows onto the stack.
-   Use the platform-defined __builtin_unwind_init if available,
-   obviating the need for machine dependent methods.  */
-#ifndef HAVE___BUILTIN_UNWIND_INIT
-# ifdef __sparc__
-   /* This trick flushes the register windows so that all the state of
-      the process is contained in the stack.
-      FreeBSD does not have a ta 3 handler, so handle it specially.
-      FIXME: Code in the Boehm GC suggests flushing (with 'flushrs') is
-      needed on ia64 too.  See mach_dep.c, where it also says inline
-      assembler doesn't work with relevant proprietary compilers.  */
-#  if defined __sparc64__ && defined __FreeBSD__
-#   define __builtin_unwind_init() asm ("flushw")
-#  else
-#   define __builtin_unwind_init() asm ("ta 3")
-#  endif
-# else
-#  define __builtin_unwind_init() ((void) 0)
-# endif
-#endif
-
 /* Yield an address close enough to the top of the stack that the
    garbage collector need not scan above it.  Callers should be
    declared NO_INLINE.  */
@@ -5042,16 +5033,14 @@ typedef union
    We have to mark Lisp objects in CPU registers that can hold local
    variables or are used to pass parameters.
 
-   This code assumes that calling setjmp saves registers we need
+   If __builtin_unwind_init is available, it should suffice to save
+   registers.
+
+   Otherwise, assume that calling setjmp saves registers we need
    to see in a jmp_buf which itself lies on the stack.  This doesn't
    have to be true!  It must be verified for each system, possibly
    by taking a look at the source code of setjmp.
 
-   If __builtin_unwind_init is available (defined by GCC >= 2.8) we
-   can use it as a machine independent method to store all registers
-   to the stack.  In this case the macros described in the previous
-   two paragraphs are not used.
-
    Stack Layout
 
    Architectures differ in the way their processor stack is organized.
diff --git a/src/buffer.c b/src/buffer.c
index f1cb4d50414..e441499aeb0 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -28,6 +28,10 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include <stdlib.h>
 #include <unistd.h>
 
+#ifdef HAVE_SANITIZER_LSAN_INTERFACE_H
+#include <sanitizer/lsan_interface.h>
+#endif
+
 #include <verify.h>
 
 #include "lisp.h"
@@ -5083,6 +5087,9 @@ enlarge_buffer_text (struct buffer *b, ptrdiff_t delta)
 #else
   p = xrealloc (b->text->beg, new_nbytes);
 #endif
+#ifdef HAVE___LSAN_IGNORE_OBJECT
+  __lsan_ignore_object (p);
+#endif
 
   if (p == NULL)
     {
diff --git a/src/composite.c b/src/composite.c
index 2c589e4f3a9..f96f0b77726 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1167,7 +1167,9 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
    character to check, and CHARPOS and BYTEPOS are indices in the
    string.  In that case, FACE must not be NULL.  BIDI_LEVEL is the bidi
    embedding level of the current paragraph, and is used to calculate the
-   direction argument to pass to the font shaper.
+   direction argument to pass to the font shaper; value of -1 means the
+   caller doesn't know the embedding level (used by callers which didn't
+   invoke the display routines that perform bidi-display-reordering).
 
    If the character is composed, setup members of CMP_IT (id, nglyphs,
    from, to, reversed_p), and return true.  Otherwise, update
@@ -1213,7 +1215,9 @@ composition_reseat_it (struct composition_it *cmp_it, ptrdiff_t charpos,
         continue;
       if (charpos < endpos)
         {
-          if ((bidi_level & 1) == 0)
+          if (bidi_level < 0)
+            direction = Qnil;
+          else if ((bidi_level & 1) == 0)
             direction = QL2R;
           else
             direction = QR2L;
@@ -1250,7 +1254,16 @@ composition_reseat_it (struct composition_it *cmp_it, ptrdiff_t charpos,
               else
                 bpos = CHAR_TO_BYTE (cpos);
             }
-          if ((bidi_level & 1) == 0)
+          /* The bidi_level < 0 case below strictly speaking should
+             never happen, since we get here when bidi scan direction
+             is backward in the buffer, which can only happen if the
+             display routines were called to perform the bidi
+             reordering.  But it doesn't harm to test for that, and
+             avoid someon raising their brows and thinking it's a
+             subtle bug...  */
+          if (bidi_level < 0)
+            direction = Qnil;
+          else if ((bidi_level & 1) == 0)
             direction = QL2R;
           else
             direction = QR2L;
diff --git a/src/data.c b/src/data.c
index 3088487c60c..e827695d295 100644
--- a/src/data.c
+++ b/src/data.c
@@ -23,6 +23,10 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include <math.h>
 #include <stdio.h>
 
+#ifdef HAVE_SANITIZER_LSAN_INTERFACE_H
+#include <sanitizer/lsan_interface.h>
+#endif
+
 #include <byteswap.h>
 #include <count-one-bits.h>
 #include <count-trailing-zeros.h>
@@ -1830,6 +1834,9 @@ make_blv (struct Lisp_Symbol *sym, bool forwarded,
   set_blv_defcell (blv, tem);
   set_blv_valcell (blv, tem);
   set_blv_found (blv, false);
+#ifdef HAVE___LSAN_IGNORE_OBJECT
+  __lsan_ignore_object (blv);
+#endif
   return blv;
 }
 
diff --git a/src/dispextern.h b/src/dispextern.h
index e1d6eddc419..311867a0c8c 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -3538,7 +3538,7 @@ void recompute_basic_faces (struct frame *);
 int face_at_buffer_position (struct window *, ptrdiff_t, ptrdiff_t *,
                              ptrdiff_t, bool, int, enum lface_attribute_index);
 int face_for_overlay_string (struct window *, ptrdiff_t, ptrdiff_t *, ptrdiff_t,
-                             bool, Lisp_Object);
+                             bool, Lisp_Object, enum lface_attribute_index);
 int face_at_string_position (struct window *, Lisp_Object, ptrdiff_t, ptrdiff_t,
                              ptrdiff_t *, enum face_id, bool,
                              enum lface_attribute_index);
diff --git a/src/emacs-module.c b/src/emacs-module.c
index e4e7da088d7..f57101946b3 100644
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -84,6 +84,10 @@ To add a new module function, proceed as follows:
 #include <stdlib.h>
 #include <time.h>
 
+#ifdef HAVE_SANITIZER_LSAN_INTERFACE_H
+#include <sanitizer/lsan_interface.h>
+#endif
+
 #include "lisp.h"
 #include "bignum.h"
 #include "dynlib.h"
@@ -190,7 +194,7 @@ struct emacs_runtime_private
 /* Forward declarations.  */
 
 static Lisp_Object value_to_lisp (emacs_value);
-static emacs_value allocate_emacs_value (emacs_env *, struct emacs_value_storage *, Lisp_Object);
+static emacs_value allocate_emacs_value (emacs_env *, Lisp_Object);
 static emacs_value lisp_to_value (emacs_env *, Lisp_Object);
 static enum emacs_funcall_exit module_non_local_exit_check (emacs_env *);
 static void module_assert_thread (void);
@@ -1095,7 +1099,16 @@ DEFUN ("module-load", Fmodule_load, Smodule_load, 1, 1, 0,
      for two different runtime objects are guaranteed to be distinct,
      which we can use for checking the liveness of runtime
      pointers.  */
-  struct emacs_runtime *rt = module_assertions ? xmalloc (sizeof *rt) : &rt_pub;
+  struct emacs_runtime *rt;
+  if (module_assertions)
+    {
+      rt = xmalloc (sizeof *rt);
+#ifdef HAVE___LSAN_IGNORE_OBJECT
+      __lsan_ignore_object (rt);
+#endif
+    }
+  else
+    rt = &rt_pub;
   rt->size = sizeof *rt;
   rt->private_members = &rt_priv;
   rt->get_environment = module_get_environment;
@@ -1321,7 +1334,7 @@ lisp_to_value (emacs_env *env, Lisp_Object o)
   struct emacs_env_private *p = env->private_members;
   if (p->pending_non_local_exit != emacs_funcall_exit_return)
     return NULL;
-  return allocate_emacs_value (env, &p->storage, o);
+  return allocate_emacs_value (env, o);
 }
 
 /* Must be called for each frame before it can be used for allocation.  */
@@ -1358,9 +1371,9 @@ finalize_storage (struct emacs_value_storage *storage)
 /* Allocate a new value from STORAGE and stores OBJ in it.  Return
    NULL if allocation fails and use ENV for non local exit reporting.  */
 static emacs_value
-allocate_emacs_value (emacs_env *env, struct emacs_value_storage *storage,
-                      Lisp_Object obj)
+allocate_emacs_value (emacs_env *env, Lisp_Object obj)
 {
+  struct emacs_value_storage *storage = &env->private_members->storage;
   eassert (storage->current);
   eassert (storage->current->offset < value_frame_size);
   eassert (! storage->current->next);
@@ -1411,7 +1424,12 @@ static emacs_env *
 initialize_environment (emacs_env *env, struct emacs_env_private *priv)
 {
   if (module_assertions)
+    {
       env = xmalloc (sizeof *env);
+#ifdef HAVE___LSAN_IGNORE_OBJECT
+      __lsan_ignore_object (env);
+#endif
+    }
 
   priv->pending_non_local_exit = emacs_funcall_exit_return;
   initialize_storage (&priv->storage);
diff --git a/src/fileio.c b/src/fileio.c
index 2f1d2f82433..37072d9b6bd 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -2031,7 +2031,7 @@ permissions.  */)
   ptrdiff_t count = SPECPDL_INDEX ();
   Lisp_Object encoded_file, encoded_newname;
 #if HAVE_LIBSELINUX
-  security_context_t con;
+  char *con;
   int conlength = 0;
 #endif
 #ifdef WINDOWSNT
@@ -3118,7 +3118,7 @@ or if SELinux is disabled, or if Emacs lacks SELinux support.  */)
 #if HAVE_LIBSELINUX
   if (is_selinux_enabled ())
     {
-      security_context_t con;
+      char *con;
       int conlength = lgetfilecon (SSDATA (ENCODE_FILE (absname)), &con);
       if (conlength > 0)
         {
@@ -3163,7 +3163,7 @@ or if Emacs was not compiled with SELinux support.  */)
   Lisp_Object role = CAR_SAFE (CDR_SAFE (context));
   Lisp_Object type = CAR_SAFE (CDR_SAFE (CDR_SAFE (context)));
   Lisp_Object range = CAR_SAFE (CDR_SAFE (CDR_SAFE (CDR_SAFE (context))));
-  security_context_t con;
+  char *con;
   bool fail;
   int conlength;
   context_t parsed_con;
diff --git a/src/indent.c b/src/indent.c
index c0b4c13b2c5..581323b91ee 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -596,7 +596,7 @@ scan_for_column (ptrdiff_t *endpos, EMACS_INT *goalcol, ptrdiff_t *prevcol)
       if (cmp_it.id >= 0
           || (scan == cmp_it.stop_pos
               && composition_reseat_it (&cmp_it, scan, scan_byte, end,
-                                        w, NEUTRAL_DIR, NULL, Qnil)))
+                                        w, -1, NULL, Qnil)))
         composition_update_it (&cmp_it, scan, scan_byte, Qnil);
       if (cmp_it.id >= 0)
         {
@@ -1504,7 +1504,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
           if (cmp_it.id >= 0
               || (pos == cmp_it.stop_pos
                   && composition_reseat_it (&cmp_it, pos, pos_byte, to, win,
-                                            NEUTRAL_DIR, NULL, Qnil)))
+                                            -1, NULL, Qnil)))
             composition_update_it (&cmp_it, pos, pos_byte, Qnil);
           if (cmp_it.id >= 0)
             {
diff --git a/src/lisp.h b/src/lisp.h
index 54ade65443f..5ef31eff31e 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3822,6 +3822,25 @@ extern void mark_maybe_objects (Lisp_Object const *, ptrdiff_t);
 extern void mark_stack (char const *, char const *);
 extern void flush_stack_call_func1 (void (*func) (void *arg), void *arg);
 
+/* Force callee-saved registers and register windows onto the stack,
+   so that conservative garbage collection can see their values.  */
+#ifndef HAVE___BUILTIN_UNWIND_INIT
+# ifdef __sparc__
+   /* This trick flushes the register windows so that all the state of
+      the process is contained in the stack.
+      FreeBSD does not have a ta 3 handler, so handle it specially.
+      FIXME: Code in the Boehm GC suggests flushing (with 'flushrs') is
+      needed on ia64 too.  See mach_dep.c, where it also says inline
+      assembler doesn't work with relevant proprietary compilers.  */
+#  if defined __sparc64__ && defined __FreeBSD__
+#   define __builtin_unwind_init() asm ("flushw")
+#  else
+#   define __builtin_unwind_init() asm ("ta 3")
+#  endif
+# else
+#  define __builtin_unwind_init() ((void) 0)
+# endif
+#endif
 INLINE void
 flush_stack_call_func (void (*func) (void *arg), void *arg)
 {
diff --git a/src/nsterm.m b/src/nsterm.m
index 0e405fc0175..df7f716f51e 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -5476,7 +5476,8 @@ ns_term_init (Lisp_Object display_name)
   {
     NSColorList *cl = [NSColorList colorListNamed: @"Emacs"];
 
-    if ( cl == nil )
+    /* There are 752 colors defined in rgb.txt.  */
+    if ( cl == nil || [[cl allKeys] count] < 752)
       {
         Lisp_Object color_file, color_map, color;
         unsigned long c;
diff --git a/src/pdumper.c b/src/pdumper.c
index 2bda3a85cd1..28529d63648 100644
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -764,8 +764,9 @@ dump_off_from_lisp (Lisp_Object value)
   intmax_t n = intmax_t_from_lisp (value);
   eassert (DUMP_OFF_MIN <= n && n <= DUMP_OFF_MAX);
   ALLOW_IMPLICIT_CONVERSION;
-  return n;
+  dump_off converted = n;
   DISALLOW_IMPLICIT_CONVERSION;
+  return converted;
 }
 
 static Lisp_Object
diff --git a/src/regex-emacs.c b/src/regex-emacs.c
index ba7f3cef64b..1ecbc74b96c 100644
--- a/src/regex-emacs.c
+++ b/src/regex-emacs.c
@@ -29,6 +29,10 @@
 
 #include <stdlib.h>
 
+#ifdef HAVE_SANITIZER_LSAN_INTERFACE_H
+#include <sanitizer/lsan_interface.h>
+#endif
+
 #include "character.h"
 #include "buffer.h"
 #include "syntax.h"
@@ -1757,6 +1761,9 @@ regex_compile (re_char *pattern, ptrdiff_t size,
   /* Initialize the compile stack.  */
   compile_stack.stack = xmalloc (INIT_COMPILE_STACK_SIZE
                                  * sizeof *compile_stack.stack);
+#ifdef HAVE___LSAN_IGNORE_OBJECT
+  __lsan_ignore_object (compile_stack.stack);
+#endif
   compile_stack.size = INIT_COMPILE_STACK_SIZE;
   compile_stack.avail = 0;
 
diff --git a/src/search.c b/src/search.c
index ec076c18035..7b74ff91480 100644
--- a/src/search.c
+++ b/src/search.c
@@ -21,6 +21,10 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
+#ifdef HAVE_SANITIZER_LSAN_INTERFACE_H
+#include <sanitizer/lsan_interface.h>
+#endif
+
 #include "lisp.h"
 #include "character.h"
 #include "buffer.h"
@@ -613,7 +617,12 @@ newline_cache_on_off (struct buffer *buf)
         {
           /* It should be on.  */
           if (base_buf->newline_cache == 0)
-            base_buf->newline_cache = new_region_cache ();
+            {
+              base_buf->newline_cache = new_region_cache ();
+#ifdef HAVE___LSAN_IGNORE_OBJECT
+              __lsan_ignore_object (base_buf->newline_cache);
+#endif
+            }
         }
       return base_buf->newline_cache;
     }
diff --git a/src/xdisp.c b/src/xdisp.c
index eb7f3e7baa1..fc17014c029 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -4339,7 +4339,7 @@ face_at_pos (const struct it *it, enum lface_attribute_index attr_filter)
                                        (IT_CHARPOS (*it)
                                         + TEXT_PROP_DISTANCE_LIMIT),
                                        false,
-                                       from_overlay);
+                                       from_overlay, attr_filter);
         }
       else
         {
diff --git a/src/xfaces.c b/src/xfaces.c
index c4a4e1c94f3..585cfa1cf4a 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -6475,7 +6475,8 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
 int
 face_for_overlay_string (struct window *w, ptrdiff_t pos,
                          ptrdiff_t *endptr, ptrdiff_t limit,
-                         bool mouse, Lisp_Object overlay)
+                         bool mouse, Lisp_Object overlay,
+                         enum lface_attribute_index attr_filter)
 {
   struct frame *f = XFRAME (w->frame);
   Lisp_Object attrs[LFACE_VECTOR_SIZE];
@@ -6514,7 +6515,7 @@ face_for_overlay_string (struct window *w, ptrdiff_t pos,
 
   /* Merge in attributes specified via text properties.  */
   if (!NILP (prop))
-    merge_face_ref (w, f, prop, attrs, true, NULL, 0);
+    merge_face_ref (w, f, prop, attrs, true, NULL, attr_filter);
 
   *endptr = endpos;