upstream

1 files changed, 62 insertions, 62 deletions

diff --git a/src/alloc.c b/src/alloc.c
index 188a514376d..33dc68df48e 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -26,7 +26,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <limits.h>             /* For CHAR_BIT.  */
 #include <setjmp.h>
 
-#include <signal.h>
+#ifdef ENABLE_CHECKING
+#include <signal.h>             /* For SIGABRT. */
+#endif
 
 #ifdef HAVE_PTHREAD
 #include <pthread.h>
@@ -42,7 +44,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "keyboard.h"
 #include "frame.h"
 #include "blockinput.h"
-#include "syssignal.h"
 #include "termhooks.h"          /* For struct terminal.  */
 #include <setjmp.h>
 #include <verify.h>
@@ -278,6 +279,7 @@ static void gc_sweep (void);
 static Lisp_Object make_pure_vector (ptrdiff_t);
 static void mark_glyph_matrix (struct glyph_matrix *);
 static void mark_face_cache (struct face_cache *);
+static void mark_buffer (struct buffer *);
 
 #if !defined REL_ALLOC || defined SYSTEM_MALLOC
 static void refill_memory_reserve (void);
@@ -613,7 +615,7 @@ overrun_check_malloc (size_t size)
   register unsigned char *val;
   int overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_OVERHEAD : 0;
   if (SIZE_MAX - overhead < size)
-    abort ();
+    emacs_abort ();
 
   val = malloc (size + overhead);
   if (val && check_depth == 1)
@@ -638,7 +640,7 @@ overrun_check_realloc (void *block, size_t size)
   register unsigned char *val = (unsigned char *) block;
   int overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_OVERHEAD : 0;
   if (SIZE_MAX - overhead < size)
-    abort ();
+    emacs_abort ();
 
   if (val
       && check_depth == 1
@@ -649,7 +651,7 @@ overrun_check_realloc (void *block, size_t size)
       size_t osize = xmalloc_get_size (val);
       if (memcmp (xmalloc_overrun_check_trailer, val + osize,
                   XMALLOC_OVERRUN_CHECK_SIZE))
-        abort ();
+        emacs_abort ();
       memset (val + osize, 0, XMALLOC_OVERRUN_CHECK_SIZE);
       val -= XMALLOC_OVERRUN_CHECK_SIZE + XMALLOC_OVERRUN_SIZE_SIZE;
       memset (val, 0, XMALLOC_OVERRUN_CHECK_SIZE + XMALLOC_OVERRUN_SIZE_SIZE);
@@ -686,7 +688,7 @@ overrun_check_free (void *block)
       size_t osize = xmalloc_get_size (val);
       if (memcmp (xmalloc_overrun_check_trailer, val + osize,
                   XMALLOC_OVERRUN_CHECK_SIZE))
-        abort ();
+        emacs_abort ();
 #ifdef XMALLOC_CLEAR_FREE_MEMORY
       val -= XMALLOC_OVERRUN_CHECK_SIZE + XMALLOC_OVERRUN_SIZE_SIZE;
       memset (val, 0xff, osize + XMALLOC_OVERRUN_CHECK_OVERHEAD);
@@ -1272,7 +1274,7 @@ emacs_blocked_free (void *ptr, const void *ptr2)
         {
           fprintf (stderr,
                    "Freeing `%p' which wasn't allocated with malloc\n", ptr);
-          abort ();
+          emacs_abort ();
         }
       else
         {
@@ -1331,7 +1333,7 @@ emacs_blocked_malloc (size_t size, const void *ptr)
         fprintf (stderr, "Region in use is %p...%p, %td bytes, type %d\n",
                  m->start, m->end, (char *) m->end - (char *) m->start,
                  m->type);
-        abort ();
+        emacs_abort ();
       }
 
     if (!dont_register_blocks)
@@ -1369,7 +1371,7 @@ emacs_blocked_realloc (void *ptr, size_t size, const void *ptr2)
           fprintf (stderr,
                    "Realloc of %p which wasn't allocated with malloc\n",
                    ptr);
-          abort ();
+          emacs_abort ();
         }
 
       mem_delete (m);
@@ -1391,7 +1393,7 @@ emacs_blocked_realloc (void *ptr, size_t size, const void *ptr2)
     if (m != MEM_NIL)
       {
         fprintf (stderr, "Realloc returns memory that is already in use\n");
-        abort ();
+        emacs_abort ();
       }
 
     /* Can't handle zero size regions in the red-black tree.  */
@@ -1804,7 +1806,7 @@ string_bytes (struct Lisp_String *s)
   if (!PURE_POINTER_P (s)
       && s->data
       && nbytes != SDATA_NBYTES (SDATA_OF_STRING (s)))
-    abort ();
+    emacs_abort ();
   return nbytes;
 }
 
@@ -1878,7 +1880,7 @@ check_string_free_list (void)
   while (s != NULL)
     {
       if ((uintptr_t) s < 1024)
-        abort ();
+        emacs_abort ();
       s = NEXT_FREE_LISP_STRING (s);
     }
 }
@@ -2107,7 +2109,7 @@ sweep_strings (void)
                      back-pointer so that we know it's free.  */
 #ifdef GC_CHECK_STRING_BYTES
                   if (string_bytes (s) != SDATA_NBYTES (data))
-                    abort ();
+                    emacs_abort ();
 #else
                   data->u.nbytes = STRING_BYTES (s);
 #endif
@@ -2218,7 +2220,7 @@ compact_small_strings (void)
           /* Check that the string size recorded in the string is the
              same as the one recorded in the sdata structure. */
           if (s && string_bytes (s) != SDATA_NBYTES (from))
-            abort ();
+            emacs_abort ();
 #endif /* GC_CHECK_STRING_BYTES */
 
           nbytes = s ? STRING_BYTES (s) : SDATA_NBYTES (from);
@@ -2231,7 +2233,7 @@ compact_small_strings (void)
           if (memcmp (string_overrun_cookie,
                       (char *) from_end - GC_STRING_OVERRUN_COOKIE_SIZE,
                       GC_STRING_OVERRUN_COOKIE_SIZE))
-            abort ();
+            emacs_abort ();
 #endif
 
           /* Non-NULL S means it's alive.  Copy its data.  */
@@ -2488,7 +2490,7 @@ make_uninit_multibyte_string (EMACS_INT nchars, EMACS_INT nbytes)
   struct Lisp_String *s;
 
   if (nchars < 0)
-    abort ();
+    emacs_abort ();
   if (!nbytes)
     return empty_multibyte_string;
 
@@ -2809,7 +2811,7 @@ listn (enum constype type, ptrdiff_t count, Lisp_Object arg, ...)
       else if (type == CONSTYPE_HEAP)
         val = Fcons (objp[i], val);
       else
-        abort ();
+        emacs_abort ();
     }
   return val;
 }
@@ -3281,7 +3283,10 @@ allocate_buffer (void)
 
   XSETPVECTYPESIZE (b, PVEC_BUFFER, (offsetof (struct buffer, own_text)
                                      - header_size) / word_size);
-  /* Note that the fields of B are not initialized.  */
+  /* Put B on the chain of all buffers including killed ones.  */
+  b->header.next.buffer = all_buffers;
+  all_buffers = b;
+  /* Note that the rest fields of B are not initialized.  */
   return b;
 }
 
@@ -3919,7 +3924,7 @@ mem_insert (void *start, void *end, enum mem_type type)
   while (c != MEM_NIL)
     {
       if (start >= c->start && start < c->end)
-        abort ();
+        emacs_abort ();
       parent = c;
       c = start < c->start ? c->left : c->right;
     }
@@ -3938,7 +3943,7 @@ mem_insert (void *start, void *end, enum mem_type type)
 #ifdef GC_MALLOC_CHECK
   x = _malloc_internal (sizeof *x);
   if (x == NULL)
-    abort ();
+    emacs_abort ();
 #else
   x = xmalloc (sizeof *x);
 #endif
@@ -4613,7 +4618,7 @@ mark_maybe_pointer (void *p)
           break;
 
         default:
-          abort ();
+          emacs_abort ();
         }
 
       if (!NILP (obj))
@@ -4764,7 +4769,7 @@ test_setjmp (void)
   x = strlen (buf);
   x = 2 * x - 1;
 
-  setjmp (jbuf);
+  _setjmp (jbuf);
   if (longjmps_done == 1)
     {
       /* Came here after the longjmp at the end of the function.
@@ -4789,7 +4794,7 @@ test_setjmp (void)
   ++longjmps_done;
   x = 2;
   if (longjmps_done == 1)
-    longjmp (jbuf, 1);
+    _longjmp (jbuf, 1);
 }
 
 #endif /* not GC_SAVE_REGISTERS_ON_STACK && not GC_SETJMP_WORKS */
@@ -4810,7 +4815,7 @@ check_gcpros (void)
       if (!survives_gc_p (p->var[i]))
         /* FIXME: It's not necessarily a bug.  It might just be that the
            GCPRO is unnecessary or should release the object sooner.  */
-        abort ();
+        emacs_abort ();
 }
 
 #elif GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES
@@ -4931,7 +4936,7 @@ mark_stack (void)
     }
 #endif /* GC_SETJMP_WORKS */
 
-  setjmp (j.j);
+  _setjmp (j.j);
   end = stack_grows_down_p ? (char *) &j + sizeof j : (char *) &j;
 #endif /* not GC_SAVE_REGISTERS_ON_STACK */
 #endif /* not HAVE___BUILTIN_UNWIND_INIT */
@@ -4981,7 +4986,8 @@ valid_pointer_p (void *p)
 #endif
 }
 
-/* Return 1 if OBJ is a valid lisp object.
+/* Return 2 if OBJ is a killed or special buffer object.
+   Return 1 if OBJ is a valid lisp object.
    Return 0 if OBJ is NOT a valid lisp object.
    Return -1 if we cannot validate OBJ.
    This function can be quite slow,
@@ -5002,6 +5008,9 @@ valid_lisp_object_p (Lisp_Object obj)
   if (PURE_POINTER_P (p))
     return 1;
 
+  if (p == &buffer_defaults || p == &buffer_local_symbols)
+    return 2;
+
 #if !GC_MARK_STACK
   return valid_pointer_p (p);
 #else
@@ -5027,7 +5036,7 @@ valid_lisp_object_p (Lisp_Object obj)
       return 0;
 
     case MEM_TYPE_BUFFER:
-      return live_buffer_p (m, p);
+      return live_buffer_p (m, p) ? 1 : 2;
 
     case MEM_TYPE_CONS:
       return live_cons_p (m, p);
@@ -5351,7 +5360,7 @@ staticpro (Lisp_Object *varaddress)
 {
   staticvec[staticidx++] = varaddress;
   if (staticidx >= NSTATICS)
-    abort ();
+    emacs_abort ();
 }
 
 
@@ -5406,7 +5415,7 @@ See Info node `(elisp)Garbage Collection'.  */)
   Lisp_Object retval = Qnil;
 
   if (abort_on_gc)
-    abort ();
+    emacs_abort ();
 
   /* Can't GC if pure storage overflowed because we can't determine
      if something is a pure object or not.  */
@@ -5469,6 +5478,9 @@ See Info node `(elisp)Garbage Collection'.  */)
 
   /* Mark all the special slots that serve as the roots of accessibility.  */
 
+  mark_buffer (&buffer_defaults);
+  mark_buffer (&buffer_local_symbols);
+
   for (i = 0; i < staticidx; i++)
     mark_object (*staticvec[i]);
 
@@ -5887,7 +5899,7 @@ mark_object (Lisp_Object arg)
   do {                                          \
     m = mem_find (po);                          \
     if (m == MEM_NIL)                           \
-      abort ();                                 \
+      emacs_abort ();                           \
   } while (0)
 
   /* Check that the object pointed to by PO is live, using predicate
@@ -5895,7 +5907,7 @@ mark_object (Lisp_Object arg)
 #define CHECK_LIVE(LIVEP)                       \
   do {                                          \
     if (!LIVEP (m, po))                         \
-      abort ();                                 \
+      emacs_abort ();                           \
   } while (0)
 
   /* Check both of the above conditions.  */
@@ -5940,10 +5952,8 @@ mark_object (Lisp_Object arg)
 
 #ifdef GC_CHECK_MARKED_OBJECTS
         m = mem_find (po);
-        if (m == MEM_NIL && !SUBRP (obj)
-            && po != &buffer_defaults
-            && po != &buffer_local_symbols)
-          abort ();
+        if (m == MEM_NIL && !SUBRP (obj))
+          emacs_abort ();
 #endif /* GC_CHECK_MARKED_OBJECTS */
 
         if (ptr->header.size & PSEUDOVECTOR_FLAG)
@@ -5959,15 +5969,14 @@ mark_object (Lisp_Object arg)
           {
           case PVEC_BUFFER:
 #ifdef GC_CHECK_MARKED_OBJECTS
-            if (po != &buffer_defaults && po != &buffer_local_symbols)
-              {
-                struct buffer *b;
-                FOR_EACH_BUFFER (b)
-                  if (b == po)
-                    break;
-                if (b == NULL)
-                  abort ();
-              }
+            {
+              struct buffer *b;
+              FOR_EACH_BUFFER (b)
+                if (b == po)
+                  break;
+              if (b == NULL)
+                emacs_abort ();
+            }
 #endif /* GC_CHECK_MARKED_OBJECTS */
             mark_buffer ((struct buffer *) ptr);
             break;
@@ -5992,10 +6001,8 @@ mark_object (Lisp_Object arg)
             break;
 
           case PVEC_FRAME:
-            {
-              mark_vectorlike (ptr);
-              mark_face_cache (((struct frame *) ptr)->face_cache);
-            }
+            mark_vectorlike (ptr);
+            mark_face_cache (((struct frame *) ptr)->face_cache);
             break;
 
           case PVEC_WINDOW:
@@ -6042,7 +6049,7 @@ mark_object (Lisp_Object arg)
             break;
 
           case PVEC_FREE:
-            abort ();
+            emacs_abort ();
 
           default:
             mark_vectorlike (ptr);
@@ -6089,7 +6096,7 @@ mark_object (Lisp_Object arg)
                And if it's forwarded to a C variable, either it's not
                a Lisp_Object var, or it's staticpro'd already.  */
             break;
-          default: abort ();
+          default: emacs_abort ();
           }
         if (!PURE_POINTER_P (XSTRING (ptr->name)))
           MARK_STRING (XSTRING (ptr->name));
@@ -6143,7 +6150,7 @@ mark_object (Lisp_Object arg)
           break;
 
         default:
-          abort ();
+          emacs_abort ();
         }
       break;
 
@@ -6165,7 +6172,7 @@ mark_object (Lisp_Object arg)
         obj = ptr->u.cdr;
         cdr_count++;
         if (cdr_count == mark_object_loop_halt)
-          abort ();
+          emacs_abort ();
         goto loop;
       }
 
@@ -6178,7 +6185,7 @@ mark_object (Lisp_Object arg)
       break;
 
     default:
-      abort ();
+      emacs_abort ();
     }
 
 #undef CHECK_LIVE
@@ -6247,7 +6254,7 @@ survives_gc_p (Lisp_Object obj)
       break;
 
     default:
-      abort ();
+      emacs_abort ();
     }
 
   return survives_p || PURE_POINTER_P ((void *) XPNTR (obj));
@@ -6685,21 +6692,14 @@ which_symbols (Lisp_Object obj, EMACS_INT find_max)
 
 #ifdef ENABLE_CHECKING
 
-# include <execinfo.h>
-
 bool suppress_checking;
 
 void
 die (const char *msg, const char *file, int line)
 {
-  enum { NPOINTERS_MAX = 500 };
-  void *buffer[NPOINTERS_MAX];
-  int npointers;
   fprintf (stderr, "\r\n%s:%d: Emacs fatal error: %s\r\n",
            file, line, msg);
-  npointers = backtrace (buffer, NPOINTERS_MAX);
-  backtrace_symbols_fd (buffer, npointers, STDERR_FILENO);
-  abort ();
+  fatal_error_backtrace (SIGABRT, INT_MAX);
 }
 #endif