/* Storage allocation and gc for GNU Emacs Lisp interpreter.
Copyright (C) 1985, 1986, 1988, 1993, 1994, 1995, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GNU Emacs.
that the backend handles concurrent access to malloc within its own threads
but Emacs code running in the main thread is not included in that control).
- When UNBLOCK_INPUT is called, revoke_input_signal may be called. If this
+ When UNBLOCK_INPUT is called, reinvoke_input_signal may be called. If this
happens in one of the backend threads we will have two threads that tries
to run Emacs code at once, and the code is not prepared for that.
To prevent that, we only call BLOCK/UNBLOCK from the main thread. */
#define MARK_STRING(S) ((S)->size |= ARRAY_MARK_FLAG)
#define UNMARK_STRING(S) ((S)->size &= ~ARRAY_MARK_FLAG)
-#define STRING_MARKED_P(S) ((S)->size & ARRAY_MARK_FLAG)
+#define STRING_MARKED_P(S) (((S)->size & ARRAY_MARK_FLAG) != 0)
#define VECTOR_MARK(V) ((V)->size |= ARRAY_MARK_FLAG)
#define VECTOR_UNMARK(V) ((V)->size &= ~ARRAY_MARK_FLAG)
-#define VECTOR_MARKED_P(V) ((V)->size & ARRAY_MARK_FLAG)
+#define VECTOR_MARKED_P(V) (((V)->size & ARRAY_MARK_FLAG) != 0)
/* Value is the number of bytes/chars of S, a pointer to a struct
Lisp_String. This must be used instead of STRING_BYTES (S) or
static void mark_face_cache P_ ((struct face_cache *));
#ifdef HAVE_WINDOW_SYSTEM
+extern void mark_fringe_data P_ ((void));
static void mark_image P_ ((struct image *));
static void mark_image_cache P_ ((struct frame *));
#endif /* HAVE_WINDOW_SYSTEM */
val + osize,
XMALLOC_OVERRUN_CHECK_SIZE))
abort ();
+#ifdef XMALLOC_CLEAR_FREE_MEMORY
+ val -= XMALLOC_OVERRUN_CHECK_SIZE;
+ memset (val, 0xff, osize + XMALLOC_OVERRUN_CHECK_SIZE*2);
+#else
bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE);
val -= XMALLOC_OVERRUN_CHECK_SIZE;
bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
+#endif
}
free (val);
On glibc-2.3.2, malloc never tries to align, so a padding of 0 is best.
posix_memalign on the other hand would ideally prefer a value of 4
because otherwise, there's 1020 bytes wasted between each ablocks.
- But testing shows that those 1020 will most of the time be efficiently
- used by malloc to place other objects, so a value of 0 is still preferable
- unless you have a lot of cons&floats and virtually nothing else. */
+ In Emacs, testing shows that those 1020 can most of the time be
+ efficiently used by malloc to place other objects, so a value of 0 can
+ still preferable unless you have a lot of aligned blocks and virtually
+ nothing else. */
#define BLOCK_PADDING 0
#define BLOCK_BYTES \
- (BLOCK_ALIGN - sizeof (struct aligned_block *) - BLOCK_PADDING)
+ (BLOCK_ALIGN - sizeof (struct ablock *) - BLOCK_PADDING)
/* Internal data structures and constants. */
return b;
}
+\f
+#ifndef SYSTEM_MALLOC
+
+/* If we released our reserve (due to running out of memory),
+ and we have a fair amount free once again,
+ try to set aside another reserve in case we run out once more.
+
+ This is called when a relocatable block is freed in ralloc.c. */
+
+void
+refill_memory_reserve ()
+{
+ if (spare_memory == 0)
+ spare_memory = (char *) malloc ((size_t) SPARE_MEMORY);
+}
+
\f
/* Arranging to disable input signals while we're in malloc.
This only works with GNU malloc. To help out systems which can't
use GNU malloc, all the calls to malloc, realloc, and free
elsewhere in the code should be inside a BLOCK_INPUT/UNBLOCK_INPUT
- pairs; unfortunately, we have no idea what C library functions
+ pair; unfortunately, we have no idea what C library functions
might call malloc, so we can't really protect them unless you're
using GNU malloc. Fortunately, most of the major operating systems
can use GNU malloc. */
-#ifndef SYSTEM_MALLOC
+#ifndef SYNC_INPUT
+
#ifndef DOUG_LEA_MALLOC
extern void * (*__malloc_hook) P_ ((size_t));
extern void * (*__realloc_hook) P_ ((void *, size_t));
}
-/* If we released our reserve (due to running out of memory),
- and we have a fair amount free once again,
- try to set aside another reserve in case we run out once more.
-
- This is called when a relocatable block is freed in ralloc.c. */
-
-void
-refill_memory_reserve ()
-{
- if (spare_memory == 0)
- spare_memory = (char *) malloc ((size_t) SPARE_MEMORY);
-}
-
-
/* This function is the malloc hook that Emacs uses. */
static void *
__realloc_hook = emacs_blocked_realloc;
}
+#endif /* not SYNC_INPUT */
#endif /* not SYSTEM_MALLOC */
turned off in that buffer. Calling truncate_undo_list on
Qt tends to return NULL, which effectively turns undo back on.
So don't call truncate_undo_list if undo_list is Qt. */
- if (! EQ (nextb->undo_list, Qt))
+ if (! NILP (nextb->name) && ! EQ (nextb->undo_list, Qt))
truncate_undo_list (nextb);
/* Shrink buffer gaps, but skip indirect and dead buffers. */
}
mark_backtrace ();
+#ifdef HAVE_WINDOW_SYSTEM
+ mark_fringe_data ();
+#endif
+
#if GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES
mark_stack ();
#endif