Added lcrecord lists for 19.14.
slb: Lots of work on the purification and dump time code.
Synched Doug Lea malloc support from Emacs 20.2.
- og: Killed the purespace. Portable dumper.
*/
#include <config.h>
#include "extents.h"
#include "frame.h"
#include "glyphs.h"
-#include "opaque.h"
#include "redisplay.h"
#include "specifier.h"
#include "sysfile.h"
#include "window.h"
-#include "console-stream.h"
#ifdef DOUG_LEA_MALLOC
#include <malloc.h>
#endif
-#ifdef HAVE_MMAP
-#include <unistd.h>
-#include <sys/mman.h>
-#endif
-
-#ifdef PDUMP
-typedef struct
-{
- const struct lrecord_description *desc;
- int count;
-} pdump_reloc_table;
-
-static char *pdump_rt_list = 0;
-#endif
-
EXFUN (Fgarbage_collect, 0);
-/* Return the true size of a struct with a variable-length array field. */
-#define STRETCHY_STRUCT_SIZEOF(stretchy_struct_type, \
- stretchy_array_field, \
- stretchy_array_length) \
- (offsetof (stretchy_struct_type, stretchy_array_field) + \
- (offsetof (stretchy_struct_type, stretchy_array_field[1]) - \
- offsetof (stretchy_struct_type, stretchy_array_field[0])) * \
- (stretchy_array_length))
+/* #define GDB_SUCKS */
#if 0 /* this is _way_ too slow to be part of the standard debug options */
#if defined(DEBUG_XEMACS) && defined(MULE)
#endif
#endif
+/* Define this to see where all that space is going... */
+/* But the length of the printout is obnoxious, so limit it to testers */
+/* If somebody wants to see this they can ask for it.
+#ifdef DEBUG_XEMACS
+#define PURESTAT
+#endif
+*/
+
/* Define this to use malloc/free with no freelist for all datatypes,
the hope being that some debugging tools may help detect
freed memory references */
#define ALLOC_NO_POOLS
#endif
+#include "puresize.h"
+
#ifdef DEBUG_XEMACS
-static int debug_allocation;
-static int debug_allocation_backtrace_length;
+int debug_allocation;
+
+int debug_allocation_backtrace_length;
#endif
/* Number of bytes of consing done since the last gc */
EMACS_INT consing_since_gc;
+#ifdef EMACS_BTL
+extern void cadillac_record_backtrace ();
+#define INCREMENT_CONS_COUNTER_1(size) \
+ do { \
+ EMACS_INT __sz__ = ((EMACS_INT) (size)); \
+ consing_since_gc += __sz__; \
+ cadillac_record_backtrace (2, __sz__); \
+ } while (0)
+#else
#define INCREMENT_CONS_COUNTER_1(size) (consing_since_gc += (size))
+#endif /* EMACS_BTL */
#define debug_allocation_backtrace() \
do { \
INCREMENT_CONS_COUNTER_1 (size)
#endif
-#define DECREMENT_CONS_COUNTER(size) do { \
- consing_since_gc -= (size); \
- if (consing_since_gc < 0) \
- consing_since_gc = 0; \
-} while (0)
+#define DECREMENT_CONS_COUNTER(size) \
+ do { \
+ EMACS_INT __sz__ = ((EMACS_INT) (size)); \
+ if (consing_since_gc >= __sz__) \
+ consing_since_gc -= __sz__; \
+ else \
+ consing_since_gc = 0; \
+ } while (0)
/* Number of bytes of consing since gc before another gc should be done. */
EMACS_INT gc_cons_threshold;
#endif /* VIRT_ADDR_VARIES */
EMACS_INT malloc_sbrk_unused;
-/* Non-zero means we're in the process of doing the dump */
+/* Non-zero means defun should do purecopy on the function definition */
int purify_flag;
+#ifdef HEAP_IN_DATA
+extern void sheap_adjust_h();
+#endif
+
+#define PUREBEG ((char *) pure)
+
+#if 0 /* This is breathing_space in XEmacs */
+/* Points to memory space allocated as "spare",
+ to be freed if we run out of memory. */
+static char *spare_memory;
+
+/* Amount of spare memory to keep in reserve. */
+#define SPARE_MEMORY (1 << 14)
+#endif
+
+/* Index in pure at which next pure object will be allocated. */
+static size_t pure_bytes_used;
+
+#define PURIFIED(ptr) \
+((char *) (ptr) >= PUREBEG && \
+ (char *) (ptr) < PUREBEG + get_PURESIZE())
+
+/* Non-zero if pure_bytes_used > get_PURESIZE(); accounts for excess purespace needs. */
+static size_t pure_lossage;
+
#ifdef ERROR_CHECK_TYPECHECK
Error_behavior ERROR_ME, ERROR_ME_NOT, ERROR_ME_WARN;
#endif
int
-c_readonly (Lisp_Object obj)
+purified (Lisp_Object obj)
{
- return POINTER_TYPE_P (XTYPE (obj)) && C_READONLY (obj);
+ return POINTER_TYPE_P (XGCTYPE (obj)) && PURIFIED (XPNTR (obj));
}
-int
-lisp_readonly (Lisp_Object obj)
+size_t
+purespace_usage (void)
+{
+ return pure_bytes_used;
+}
+
+static int
+check_purespace (size_t size)
+{
+ if (pure_lossage)
+ {
+ pure_lossage += size;
+ return 0;
+ }
+ else if (pure_bytes_used + size > get_PURESIZE())
+ {
+ /* This can cause recursive bad behavior, we'll yell at the end */
+ /* when we're done. */
+ /* message ("\nERROR: Pure Lisp storage exhausted!\n"); */
+ pure_lossage = size;
+ return 0;
+ }
+ else
+ return 1;
+}
+
+
+\f
+#ifndef PURESTAT
+
+#define bump_purestat(p,b) DO_NOTHING
+
+#else /* PURESTAT */
+
+static int purecopying_for_bytecode;
+
+static size_t pure_sizeof (Lisp_Object /*, int recurse */);
+
+/* Keep statistics on how much of what is in purespace */
+static struct purestat
+{
+ int nobjects;
+ int nbytes;
+ CONST char *name;
+}
+ purestat_cons = {0, 0, "cons cells"},
+ purestat_float = {0, 0, "float objects"},
+ purestat_string_pname = {0, 0, "symbol-name strings"},
+ purestat_bytecode = {0, 0, "compiled-function objects"},
+ purestat_string_bytecodes = {0, 0, "byte-code strings"},
+ purestat_vector_bytecode_constants = {0, 0, "byte-constant vectors"},
+ purestat_string_interactive = {0, 0, "interactive strings"},
+#ifdef I18N3
+ purestat_string_domain = {0, 0, "domain strings"},
+#endif
+ purestat_string_documentation = {0, 0, "documentation strings"},
+ purestat_string_other_function = {0, 0, "other function strings"},
+ purestat_vector_other = {0, 0, "other vectors"},
+ purestat_string_other = {0, 0, "other strings"},
+ purestat_string_all = {0, 0, "all strings"},
+ purestat_vector_all = {0, 0, "all vectors"};
+
+static struct purestat *purestats[] =
+{
+ &purestat_cons,
+ &purestat_float,
+ &purestat_string_pname,
+ &purestat_bytecode,
+ &purestat_string_bytecodes,
+ &purestat_vector_bytecode_constants,
+ &purestat_string_interactive,
+#ifdef I18N3
+ &purestat_string_domain,
+#endif
+ &purestat_string_documentation,
+ &purestat_string_other_function,
+ &purestat_vector_other,
+ &purestat_string_other,
+ 0,
+ &purestat_string_all,
+ &purestat_vector_all
+};
+
+static void
+bump_purestat (struct purestat *purestat, size_t nbytes)
{
- return POINTER_TYPE_P (XTYPE (obj)) && LISP_READONLY (obj);
+ if (pure_lossage) return;
+ purestat->nobjects += 1;
+ purestat->nbytes += nbytes;
}
+#endif /* PURESTAT */
\f
/* Maximum amount of C stack to save when a GC happens. */
#ifndef MAX_SAVE_STACK
-#define MAX_SAVE_STACK 0 /* 16000 */
+#define MAX_SAVE_STACK 16000
#endif
/* Non-zero means ignore malloc warnings. Set during initialization. */
void *
xmalloc (size_t size)
{
- void *val = malloc (size);
+ void *val = (void *) malloc (size);
if (!val && (size != 0)) memory_full ();
return val;
}
-#ifdef xcalloc
-#undef xcalloc
-#endif
-
-static void *
-xcalloc (size_t nelem, size_t elsize)
-{
- void *val = calloc (nelem, elsize);
-
- if (!val && (nelem != 0)) memory_full ();
- return val;
-}
-
void *
xmalloc_and_zero (size_t size)
{
- return xcalloc (size, sizeof (char));
+ void *val = xmalloc (size);
+ memset (val, 0, size);
+ return val;
}
#ifdef xrealloc
{
/* We must call malloc explicitly when BLOCK is 0, since some
reallocs don't do this. */
- void *val = block ? realloc (block, size) : malloc (size);
+ void *val = (void *) (block ? realloc (block, size) : malloc (size));
if (!val && (size != 0)) memory_full ();
return val;
void *val = xmalloc (len);
if (val == 0) return 0;
- return (char *) memcpy (val, str, len);
+ memcpy (val, str, len);
+ return (char *) val;
}
#ifdef NEED_STRDUP
static void *
allocate_lisp_storage (size_t size)
{
- return xmalloc (size);
+ void *p = xmalloc (size);
+#ifndef USE_MINIMAL_TAGBITS
+ char *lim = ((char *) p) + size;
+ Lisp_Object val;
+
+ XSETOBJ (val, Lisp_Type_Record, lim);
+ if ((char *) XPNTR (val) != lim)
+ {
+ xfree (p);
+ memory_full ();
+ }
+#endif /* ! USE_MINIMAL_TAGBITS */
+ return p;
}
{
struct lcrecord_header *lcheader;
-#ifdef ERROR_CHECK_GC
+ if (size <= 0) abort ();
if (implementation->static_size == 0)
- assert (implementation->size_in_bytes_method);
- else
- assert (implementation->static_size == size);
-#endif
+ {
+ if (!implementation->size_in_bytes_method)
+ abort ();
+ }
+ else if (implementation->static_size != size)
+ abort ();
lcheader = (struct lcrecord_header *) allocate_lisp_storage (size);
- set_lheader_implementation (&(lcheader->lheader), implementation);
+ set_lheader_implementation(&(lcheader->lheader), implementation);
lcheader->next = all_lcrecords;
#if 1 /* mly prefers to see small ID numbers */
lcheader->uid = lrecord_uid_counter++;
}
}
if (lrecord->implementation->finalizer)
- lrecord->implementation->finalizer (lrecord, 0);
+ ((lrecord->implementation->finalizer) (lrecord, 0));
xfree (lrecord);
return;
}
}
}
+
+/* This must not be called -- it just serves as for EQ test
+ * If lheader->implementation->finalizer is this_marks_a_marked_record,
+ * then lrecord has been marked by the GC sweeper
+ * header->implementation is put back to its correct value by
+ * sweep_records */
+void
+this_marks_a_marked_record (void *dummy0, int dummy1)
+{
+ abort ();
+}
+
/* Semi-kludge -- lrecord_symbol_value_forward objects get stuck
in CONST space and you get SEGV's if you attempt to mark them.
This sits in lheader->implementation->marker. */
Lisp_Object
-this_one_is_unmarkable (Lisp_Object obj)
+this_one_is_unmarkable (Lisp_Object obj, void (*markobj) (Lisp_Object))
{
abort ();
return Qnil;
}
-\f
-/************************************************************************/
-/* Debugger support */
-/************************************************************************/
-/* Give gdb/dbx enough information to decode Lisp Objects. We make
- sure certain symbols are always defined, so gdb doesn't complain
- about expressions in src/gdbinit. See src/gdbinit or src/dbxrc to
- see how this is used. */
+/* XGCTYPE for records */
+int
+gc_record_type_p (Lisp_Object frob, CONST struct lrecord_implementation *type)
+{
+ CONST struct lrecord_implementation *imp;
-EMACS_UINT dbg_valmask = ((1UL << VALBITS) - 1) << GCBITS;
-EMACS_UINT dbg_typemask = (1UL << GCTYPEBITS) - 1;
+ if (XGCTYPE (frob) != Lisp_Type_Record)
+ return 0;
-#ifdef USE_UNION_TYPE
-unsigned char dbg_USE_UNION_TYPE = 1;
+ imp = XRECORD_LHEADER_IMPLEMENTATION (frob);
+#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
+ return imp == type;
#else
-unsigned char dbg_USE_UNION_TYPE = 0;
+ return imp == type || imp == type + 1;
#endif
+}
-unsigned char Lisp_Type_Int = 100;
-unsigned char Lisp_Type_Cons = 101;
-unsigned char Lisp_Type_String = 102;
-unsigned char Lisp_Type_Vector = 103;
-unsigned char Lisp_Type_Symbol = 104;
-
-#ifndef MULE
-unsigned char lrecord_char_table_entry;
-unsigned char lrecord_charset;
-#ifndef FILE_CODING
-unsigned char lrecord_coding_system;
+\f
+/**********************************************************************/
+/* Debugger support */
+/**********************************************************************/
+/* Give gdb/dbx enough information to decode Lisp Objects.
+ We make sure certain symbols are defined, so gdb doesn't complain
+ about expressions in src/gdbinit. Values are randomly chosen.
+ See src/gdbinit or src/dbxrc to see how this is used. */
+
+enum dbg_constants
+{
+#ifdef USE_MINIMAL_TAGBITS
+ dbg_valmask = (EMACS_INT) (((1UL << VALBITS) - 1) << GCBITS),
+ dbg_typemask = (EMACS_INT) ((1UL << GCTYPEBITS) - 1),
+ dbg_USE_MINIMAL_TAGBITS = 1,
+ dbg_Lisp_Type_Int = 100,
+#else /* ! USE_MIMIMAL_TAGBITS */
+ dbg_valmask = (EMACS_INT) ((1UL << VALBITS) - 1),
+ dbg_typemask = (EMACS_INT) (((1UL << GCTYPEBITS) - 1) << (VALBITS + GCMARKBITS)),
+ dbg_USE_MINIMAL_TAGBITS = 0,
+ dbg_Lisp_Type_Int = Lisp_Type_Int,
+#endif /* ! USE_MIMIMAL_TAGBITS */
+#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
+ dbg_USE_INDEXED_LRECORD_IMPLEMENTATION = 1,
+#else
+ dbg_USE_INDEXED_LRECORD_IMPLEMENTATION = 0,
#endif
+ dbg_Lisp_Type_Char = Lisp_Type_Char,
+ dbg_Lisp_Type_Record = Lisp_Type_Record,
+#ifdef LRECORD_CONS
+ dbg_Lisp_Type_Cons = 101,
+#else
+ dbg_Lisp_Type_Cons = Lisp_Type_Cons,
+ lrecord_cons = 201,
+#endif
+#ifdef LRECORD_STRING
+ dbg_Lisp_Type_String = 102,
+#else
+ dbg_Lisp_Type_String = Lisp_Type_String,
+ lrecord_string = 202,
+#endif
+#ifdef LRECORD_VECTOR
+ dbg_Lisp_Type_Vector = 103,
+#else
+ dbg_Lisp_Type_Vector = Lisp_Type_Vector,
+ lrecord_vector = 203,
+#endif
+#ifdef LRECORD_SYMBOL
+ dbg_Lisp_Type_Symbol = 104,
+#else
+ dbg_Lisp_Type_Symbol = Lisp_Type_Symbol,
+ lrecord_symbol = 204,
+#endif
+#ifndef MULE
+ lrecord_char_table_entry = 205,
+ lrecord_charset = 206,
+ lrecord_coding_system = 207,
#endif
-
#ifndef HAVE_TOOLBARS
-unsigned char lrecord_toolbar_button;
+ lrecord_toolbar_button = 208,
#endif
-
-#ifndef TOOLTALK
-unsigned char lrecord_tooltalk_message;
-unsigned char lrecord_tooltalk_pattern;
+#ifndef HAVE_TOOLTALK
+ lrecord_tooltalk_message = 210,
+ lrecord_tooltalk_pattern = 211,
#endif
-
#ifndef HAVE_DATABASE
-unsigned char lrecord_database;
+ lrecord_database = 212,
#endif
-
-unsigned char dbg_valbits = VALBITS;
-unsigned char dbg_gctypebits = GCTYPEBITS;
-
-/* Macros turned into functions for ease of debugging.
- Debuggers don't know about macros! */
-int dbg_eq (Lisp_Object obj1, Lisp_Object obj2);
-int
-dbg_eq (Lisp_Object obj1, Lisp_Object obj2)
-{
- return EQ (obj1, obj2);
-}
+ dbg_valbits = VALBITS,
+ dbg_gctypebits = GCTYPEBITS
+ /* If we don't have an actual object of this enum, pgcc (and perhaps
+ other compilers) might optimize away the entire type declaration :-( */
+} dbg_dummy;
\f
-/************************************************************************/
-/* Fixed-size type macros */
-/************************************************************************/
+/**********************************************************************/
+/* Fixed-size type macros */
+/**********************************************************************/
/* For fixed-size types that are commonly used, we malloc() large blocks
of memory at a time and subdivide them into chunks of the correct
/ sizeof (structtype))
#endif /* ALLOC_NO_POOLS */
-#define DECLARE_FIXED_TYPE_ALLOC(type, structtype) \
- \
-struct type##_block \
-{ \
- struct type##_block *prev; \
- structtype block[TYPE_ALLOC_SIZE (type, structtype)]; \
-}; \
- \
-static struct type##_block *current_##type##_block; \
-static int current_##type##_block_index; \
- \
-static structtype *type##_free_list; \
-static structtype *type##_free_list_tail; \
- \
-static void \
-init_##type##_alloc (void) \
-{ \
- current_##type##_block = 0; \
- current_##type##_block_index = \
- countof (current_##type##_block->block); \
- type##_free_list = 0; \
- type##_free_list_tail = 0; \
-} \
- \
-static int gc_count_num_##type##_in_use; \
-static int gc_count_num_##type##_freelist
-
-#define ALLOCATE_FIXED_TYPE_FROM_BLOCK(type, result) do { \
- if (current_##type##_block_index \
- == countof (current_##type##_block->block)) \
+#define DECLARE_FIXED_TYPE_ALLOC(type, structtype) \
+ \
+struct type##_block \
+{ \
+ struct type##_block *prev; \
+ structtype block[TYPE_ALLOC_SIZE (type, structtype)]; \
+}; \
+ \
+static struct type##_block *current_##type##_block; \
+static int current_##type##_block_index; \
+ \
+static structtype *type##_free_list; \
+static structtype *type##_free_list_tail; \
+ \
+static void \
+init_##type##_alloc (void) \
+{ \
+ current_##type##_block = 0; \
+ current_##type##_block_index = countof (current_##type##_block->block); \
+ type##_free_list = 0; \
+ type##_free_list_tail = 0; \
+} \
+ \
+static int gc_count_num_##type##_in_use, gc_count_num_##type##_freelist
+
+#define ALLOCATE_FIXED_TYPE_FROM_BLOCK(type, result) \
+ do { \
+ if (current_##type##_block_index \
+ == countof (current_##type##_block->block)) \
{ \
- struct type##_block *AFTFB_new = (struct type##_block *) \
- allocate_lisp_storage (sizeof (struct type##_block)); \
- AFTFB_new->prev = current_##type##_block; \
- current_##type##_block = AFTFB_new; \
+ struct type##_block *__new__ = (struct type##_block *) \
+ allocate_lisp_storage (sizeof (struct type##_block)); \
+ __new__->prev = current_##type##_block; \
+ current_##type##_block = __new__; \
current_##type##_block_index = 0; \
} \
- (result) = \
- &(current_##type##_block->block[current_##type##_block_index++]); \
-} while (0)
+ (result) = \
+ &(current_##type##_block->block[current_##type##_block_index++]); \
+ } while (0)
/* Allocate an instance of a type that is stored in blocks.
TYPE is the "name" of the type, STRUCTTYPE is the corresponding
#else /* !ERROR_CHECK_GC */
#define PUT_FIXED_TYPE_ON_FREE_LIST(type, structtype, ptr) \
-do { * (structtype **) ((char *) (ptr) + sizeof (void *)) = \
+do { * (structtype **) ((char *) ptr + sizeof (void *)) = \
type##_free_list; \
- type##_free_list = (ptr); \
+ type##_free_list = ptr; \
} while (0)
#endif /* !ERROR_CHECK_GC */
/* TYPE and STRUCTTYPE are the same as in ALLOCATE_FIXED_TYPE(). */
-#define FREE_FIXED_TYPE(type, structtype, ptr) do { \
- structtype *FFT_ptr = (ptr); \
- ADDITIONAL_FREE_##type (FFT_ptr); \
- deadbeef_memory (FFT_ptr, sizeof (structtype)); \
- PUT_FIXED_TYPE_ON_FREE_LIST (type, structtype, FFT_ptr); \
- MARK_STRUCT_AS_FREE (FFT_ptr); \
-} while (0)
+#define FREE_FIXED_TYPE(type, structtype, ptr) \
+do { structtype *_weird_ = (ptr); \
+ ADDITIONAL_FREE_##type (_weird_); \
+ deadbeef_memory (ptr, sizeof (structtype)); \
+ PUT_FIXED_TYPE_ON_FREE_LIST (type, structtype, ptr); \
+ MARK_STRUCT_AS_FREE (_weird_); \
+ } while (0)
/* Like FREE_FIXED_TYPE() but used when we are explicitly
freeing a structure through free_cons(), free_marker(), etc.
\f
-/************************************************************************/
-/* Cons allocation */
-/************************************************************************/
+/**********************************************************************/
+/* Cons allocation */
+/**********************************************************************/
DECLARE_FIXED_TYPE_ALLOC (cons, struct Lisp_Cons);
/* conses are used and freed so often that we set this really high */
/* #define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_cons 20000 */
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_cons 2000
+#ifdef LRECORD_CONS
static Lisp_Object
-mark_cons (Lisp_Object obj)
+mark_cons (Lisp_Object obj, void (*markobj) (Lisp_Object))
{
if (NILP (XCDR (obj)))
return XCAR (obj);
- mark_object (XCAR (obj));
+ (markobj) (XCAR (obj));
return XCDR (obj);
}
return 0;
}
-static const struct lrecord_description cons_description[] = {
- { XD_LISP_OBJECT, offsetof(struct Lisp_Cons, car), 2 },
- { XD_END }
-};
-
DEFINE_BASIC_LRECORD_IMPLEMENTATION ("cons", cons,
mark_cons, print_cons, 0,
cons_equal,
* handle conses.
*/
0,
- cons_description,
struct Lisp_Cons);
+#endif /* LRECORD_CONS */
DEFUN ("cons", Fcons, 2, 2, 0, /*
Create a new cons, give it CAR and CDR as components, and return it.
struct Lisp_Cons *c;
ALLOCATE_FIXED_TYPE (cons, struct Lisp_Cons, c);
- set_lheader_implementation (&(c->lheader), &lrecord_cons);
+#ifdef LRECORD_CONS
+ set_lheader_implementation (&(c->lheader), lrecord_cons);
+#endif
XSETCONS (val, c);
c->car = car;
c->cdr = cdr;
struct Lisp_Cons *c;
NOSEEUM_ALLOCATE_FIXED_TYPE (cons, struct Lisp_Cons, c);
- set_lheader_implementation (&(c->lheader), &lrecord_cons);
+#ifdef LRECORD_CONS
+ set_lheader_implementation (&(c->lheader), lrecord_cons);
+#endif
XSETCONS (val, c);
XCAR (val) = car;
XCDR (val) = cdr;
Lisp_Object val = Qnil;
Lisp_Object *argp = args + nargs;
- while (argp > args)
+ while (nargs-- > 0)
val = Fcons (*--argp, val);
return val;
}
{
Lisp_Object val = Qnil;
- size_t size = XINT (length);
+ int size = XINT (length);
- while (size--)
+ while (size-- > 0)
val = Fcons (init, val);
return val;
}
}
\f
-/************************************************************************/
-/* Float allocation */
-/************************************************************************/
+/**********************************************************************/
+/* Float allocation */
+/**********************************************************************/
#ifdef LISP_FLOAT_TYPE
struct Lisp_Float *f;
ALLOCATE_FIXED_TYPE (float, struct Lisp_Float, f);
- set_lheader_implementation (&(f->lheader), &lrecord_float);
+ set_lheader_implementation (&(f->lheader), lrecord_float);
float_data (f) = float_value;
XSETFLOAT (val, f);
return val;
#endif /* LISP_FLOAT_TYPE */
\f
-/************************************************************************/
-/* Vector allocation */
-/************************************************************************/
+/**********************************************************************/
+/* Vector allocation */
+/**********************************************************************/
+#ifdef LRECORD_VECTOR
static Lisp_Object
-mark_vector (Lisp_Object obj)
+mark_vector (Lisp_Object obj, void (*markobj) (Lisp_Object))
{
- Lisp_Vector *ptr = XVECTOR (obj);
+ struct Lisp_Vector *ptr = XVECTOR (obj);
int len = vector_length (ptr);
int i;
for (i = 0; i < len - 1; i++)
- mark_object (ptr->contents[i]);
+ (markobj) (ptr->contents[i]);
return (len > 0) ? ptr->contents[len - 1] : Qnil;
}
static size_t
size_vector (CONST void *lheader)
{
- return STRETCHY_STRUCT_SIZEOF (Lisp_Vector, contents,
- ((Lisp_Vector *) lheader)->size);
+ /* * -1 because struct Lisp_Vector includes 1 slot */
+ return sizeof (struct Lisp_Vector) +
+ ((((struct Lisp_Vector *) lheader)->size - 1) * sizeof (Lisp_Object));
}
static int
-vector_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
+vector_equal (Lisp_Object o1, Lisp_Object o2, int depth)
{
- int len = XVECTOR_LENGTH (obj1);
- if (len != XVECTOR_LENGTH (obj2))
+ int indice;
+ int len = XVECTOR_LENGTH (o1);
+ if (len != XVECTOR_LENGTH (o2))
return 0;
-
- {
- Lisp_Object *ptr1 = XVECTOR_DATA (obj1);
- Lisp_Object *ptr2 = XVECTOR_DATA (obj2);
- while (len--)
- if (!internal_equal (*ptr1++, *ptr2++, depth + 1))
+ for (indice = 0; indice < len; indice++)
+ {
+ if (!internal_equal (XVECTOR_DATA (o1) [indice],
+ XVECTOR_DATA (o2) [indice],
+ depth + 1))
return 0;
- }
+ }
return 1;
}
-static const struct lrecord_description vector_description[] = {
- { XD_LONG, offsetof(struct Lisp_Vector, size) },
- { XD_LISP_OBJECT, offsetof(struct Lisp_Vector, contents), XD_INDIRECT(0, 0) },
- { XD_END }
-};
-
DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION("vector", vector,
mark_vector, print_vector, 0,
vector_equal,
* knows how to handle vectors.
*/
0,
- vector_description,
- size_vector, Lisp_Vector);
+ size_vector, struct Lisp_Vector);
+
+/* #### should allocate `small' vectors from a frob-block */
+static struct Lisp_Vector *
+make_vector_internal (size_t sizei)
+{
+ size_t sizem = (sizeof (struct Lisp_Vector)
+ /* -1 because struct Lisp_Vector includes 1 slot */
+ + (sizei - 1) * sizeof (Lisp_Object));
+ struct Lisp_Vector *p =
+ (struct Lisp_Vector *) alloc_lcrecord (sizem, lrecord_vector);
+
+ p->size = sizei;
+ return p;
+}
+
+#else /* ! LRECORD_VECTOR */
+
+static Lisp_Object all_vectors;
/* #### should allocate `small' vectors from a frob-block */
-static Lisp_Vector *
+static struct Lisp_Vector *
make_vector_internal (size_t sizei)
{
- /* no vector_next */
- size_t sizem = STRETCHY_STRUCT_SIZEOF (Lisp_Vector, contents, sizei);
- Lisp_Vector *p = (Lisp_Vector *) alloc_lcrecord (sizem, &lrecord_vector);
+ size_t sizem = (sizeof (struct Lisp_Vector)
+ /* -1 because struct Lisp_Vector includes 1 slot,
+ * +1 to account for vector_next */
+ + (sizei - 1 + 1) * sizeof (Lisp_Object));
+ struct Lisp_Vector *p = (struct Lisp_Vector *) allocate_lisp_storage (sizem);
+
+ INCREMENT_CONS_COUNTER (sizem, "vector");
p->size = sizei;
+ vector_next (p) = all_vectors;
+ XSETVECTOR (all_vectors, p);
return p;
}
+#endif /* ! LRECORD_VECTOR */
+
Lisp_Object
-make_vector (size_t length, Lisp_Object init)
+make_vector (EMACS_INT length, Lisp_Object init)
{
- Lisp_Vector *vecp = make_vector_internal (length);
- Lisp_Object *p = vector_data (vecp);
+ int elt;
+ Lisp_Object vector;
+ struct Lisp_Vector *p;
+
+ if (length < 0)
+ length = XINT (wrong_type_argument (Qnatnump, make_int (length)));
- while (length--)
- *p++ = init;
+ p = make_vector_internal (length);
+ XSETVECTOR (vector, p);
+#if 0
+ /* Initialize big arrays full of 0's quickly, for what that's worth */
{
- Lisp_Object vector;
- XSETVECTOR (vector, vecp);
+ char *travesty = (char *) &init;
+ for (i = 1; i < sizeof (Lisp_Object); i++)
+ {
+ if (travesty[i] != travesty[0])
+ goto fill;
+ }
+ memset (vector_data (p), travesty[0], length * sizeof (Lisp_Object));
return vector;
}
+ fill:
+#endif
+ for (elt = 0; elt < length; elt++)
+ vector_data(p)[elt] = init;
+
+ return vector;
}
DEFUN ("make-vector", Fmake_vector, 2, 2, 0, /*
*/
(length, init))
{
- CONCHECK_NATNUM (length);
+ CHECK_NATNUM (length);
return make_vector (XINT (length), init);
}
*/
(int nargs, Lisp_Object *args))
{
- Lisp_Vector *vecp = make_vector_internal (nargs);
- Lisp_Object *p = vector_data (vecp);
+ Lisp_Object vector;
+ int elt;
+ struct Lisp_Vector *p = make_vector_internal (nargs);
- while (nargs--)
- *p++ = *args++;
+ for (elt = 0; elt < nargs; elt++)
+ vector_data(p)[elt] = args[elt];
- {
- Lisp_Object vector;
- XSETVECTOR (vector, vecp);
- return vector;
- }
+ XSETVECTOR (vector, p);
+ return vector;
}
Lisp_Object
}
#endif /* unused */
-/************************************************************************/
-/* Bit Vector allocation */
-/************************************************************************/
+/**********************************************************************/
+/* Bit Vector allocation */
+/**********************************************************************/
static Lisp_Object all_bit_vectors;
static struct Lisp_Bit_Vector *
make_bit_vector_internal (size_t sizei)
{
- size_t num_longs = BIT_VECTOR_LONG_STORAGE (sizei);
- size_t sizem = STRETCHY_STRUCT_SIZEOF (Lisp_Bit_Vector, bits, num_longs);
- Lisp_Bit_Vector *p = (Lisp_Bit_Vector *) allocate_lisp_storage (sizem);
- set_lheader_implementation (&(p->lheader), &lrecord_bit_vector);
+ size_t sizem = sizeof (struct Lisp_Bit_Vector) +
+ /* -1 because struct Lisp_Bit_Vector includes 1 slot */
+ sizeof (long) * (BIT_VECTOR_LONG_STORAGE (sizei) - 1);
+ struct Lisp_Bit_Vector *p =
+ (struct Lisp_Bit_Vector *) allocate_lisp_storage (sizem);
+ set_lheader_implementation (&(p->lheader), lrecord_bit_vector);
INCREMENT_CONS_COUNTER (sizem, "bit-vector");
bit_vector_length (p) = sizei;
- bit_vector_next (p) = all_bit_vectors;
+ bit_vector_next (p) = all_bit_vectors;
/* make sure the extra bits in the last long are 0; the calling
functions might not set them. */
- p->bits[num_longs - 1] = 0;
+ p->bits[BIT_VECTOR_LONG_STORAGE (sizei) - 1] = 0;
XSETBIT_VECTOR (all_bit_vectors, p);
return p;
}
Lisp_Object
-make_bit_vector (size_t length, Lisp_Object init)
+make_bit_vector (EMACS_INT length, Lisp_Object init)
{
- struct Lisp_Bit_Vector *p = make_bit_vector_internal (length);
- size_t num_longs = BIT_VECTOR_LONG_STORAGE (length);
+ Lisp_Object bit_vector;
+ struct Lisp_Bit_Vector *p;
+ EMACS_INT num_longs;
CHECK_BIT (init);
+ num_longs = BIT_VECTOR_LONG_STORAGE (length);
+ p = make_bit_vector_internal (length);
+ XSETBIT_VECTOR (bit_vector, p);
+
if (ZEROP (init))
memset (p->bits, 0, num_longs * sizeof (long));
else
{
- size_t bits_in_last = length & (LONGBITS_POWER_OF_2 - 1);
+ EMACS_INT bits_in_last = length & (LONGBITS_POWER_OF_2 - 1);
memset (p->bits, ~0, num_longs * sizeof (long));
/* But we have to make sure that the unused bits in the
- last long are 0, so that equal/hash is easy. */
+ last integer are 0, so that equal/hash is easy. */
if (bits_in_last)
p->bits[num_longs - 1] &= (1 << bits_in_last) - 1;
}
- {
- Lisp_Object bit_vector;
- XSETBIT_VECTOR (bit_vector, p);
- return bit_vector;
- }
+ return bit_vector;
}
Lisp_Object
-make_bit_vector_from_byte_vector (unsigned char *bytevec, size_t length)
+make_bit_vector_from_byte_vector (unsigned char *bytevec, EMACS_INT length)
{
+ Lisp_Object bit_vector;
+ struct Lisp_Bit_Vector *p;
int i;
- Lisp_Bit_Vector *p = make_bit_vector_internal (length);
+
+ if (length < 0)
+ length = XINT (wrong_type_argument (Qnatnump, make_int (length)));
+
+ p = make_bit_vector_internal (length);
+ XSETBIT_VECTOR (bit_vector, p);
for (i = 0; i < length; i++)
set_bit_vector_bit (p, i, bytevec[i]);
- {
- Lisp_Object bit_vector;
- XSETBIT_VECTOR (bit_vector, p);
- return bit_vector;
- }
+ return bit_vector;
}
DEFUN ("make-bit-vector", Fmake_bit_vector, 2, 2, 0, /*
*/
(int nargs, Lisp_Object *args))
{
- int i;
- Lisp_Bit_Vector *p = make_bit_vector_internal (nargs);
+ Lisp_Object bit_vector;
+ int elt;
+ struct Lisp_Bit_Vector *p;
- for (i = 0; i < nargs; i++)
- {
- CHECK_BIT (args[i]);
- set_bit_vector_bit (p, i, !ZEROP (args[i]));
- }
+ for (elt = 0; elt < nargs; elt++)
+ CHECK_BIT (args[elt]);
- {
- Lisp_Object bit_vector;
- XSETBIT_VECTOR (bit_vector, p);
- return bit_vector;
- }
+ p = make_bit_vector_internal (nargs);
+
+ for (elt = 0; elt < nargs; elt++)
+ set_bit_vector_bit (p, elt, !ZEROP (args[elt]));
+
+ XSETBIT_VECTOR (bit_vector, p);
+ return bit_vector;
}
\f
-/************************************************************************/
-/* Compiled-function allocation */
-/************************************************************************/
+/**********************************************************************/
+/* Compiled-function allocation */
+/**********************************************************************/
-DECLARE_FIXED_TYPE_ALLOC (compiled_function, Lisp_Compiled_Function);
+DECLARE_FIXED_TYPE_ALLOC (compiled_function, struct Lisp_Compiled_Function);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_compiled_function 1000
static Lisp_Object
-make_compiled_function (void)
-{
- Lisp_Compiled_Function *f;
- Lisp_Object fun;
-
- ALLOCATE_FIXED_TYPE (compiled_function, Lisp_Compiled_Function, f);
- set_lheader_implementation (&(f->lheader), &lrecord_compiled_function);
-
- f->stack_depth = 0;
- f->specpdl_depth = 0;
- f->flags.documentationp = 0;
- f->flags.interactivep = 0;
- f->flags.domainp = 0; /* I18N3 */
- f->instructions = Qzero;
- f->constants = Qzero;
- f->arglist = Qnil;
- f->doc_and_interactive = Qnil;
+make_compiled_function (int make_pure)
+{
+ struct Lisp_Compiled_Function *b;
+ Lisp_Object new;
+ size_t size = sizeof (struct Lisp_Compiled_Function);
+
+ if (make_pure && check_purespace (size))
+ {
+ b = (struct Lisp_Compiled_Function *) (PUREBEG + pure_bytes_used);
+ set_lheader_implementation (&(b->lheader), lrecord_compiled_function);
+#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
+ b->lheader.pure = 1;
+#endif
+ pure_bytes_used += size;
+ bump_purestat (&purestat_bytecode, size);
+ }
+ else
+ {
+ ALLOCATE_FIXED_TYPE (compiled_function, struct Lisp_Compiled_Function,
+ b);
+ set_lheader_implementation (&(b->lheader), lrecord_compiled_function);
+ }
+ b->maxdepth = 0;
+ b->flags.documentationp = 0;
+ b->flags.interactivep = 0;
+ b->flags.domainp = 0; /* I18N3 */
+ b->bytecodes = Qzero;
+ b->constants = Qzero;
+ b->arglist = Qnil;
+ b->doc_and_interactive = Qnil;
#ifdef COMPILED_FUNCTION_ANNOTATION_HACK
- f->annotated = Qnil;
+ b->annotated = Qnil;
#endif
- XSETCOMPILED_FUNCTION (fun, f);
- return fun;
+ XSETCOMPILED_FUNCTION (new, b);
+ return new;
}
DEFUN ("make-byte-code", Fmake_byte_code, 4, MANY, 0, /*
Return a new compiled-function object.
-Usage: (arglist instructions constants stack-depth
- &optional doc-string interactive)
+Usage: (arglist instructions constants stack-size
+ &optional doc-string interactive-spec)
Note that, unlike all other emacs-lisp functions, calling this with five
arguments is NOT the same as calling it with six arguments, the last of
which is nil. If the INTERACTIVE arg is specified as nil, then that means
that this function was defined with `(interactive)'. If the arg is not
specified, then that means the function is not interactive.
This is terrible behavior which is retained for compatibility with old
-`.elc' files which expect these semantics.
+`.elc' files which expected these semantics.
*/
(int nargs, Lisp_Object *args))
{
-/* In a non-insane world this function would have this arglist...
- (arglist instructions constants stack_depth &optional doc_string interactive)
+/* In a non-insane world this function would have this arglist...
+ (arglist, instructions, constants, stack_size, doc_string, interactive)
+ Lisp_Object arglist, instructions, constants, stack_size, doc_string,
+ interactive;
*/
- Lisp_Object fun = make_compiled_function ();
- Lisp_Compiled_Function *f = XCOMPILED_FUNCTION (fun);
-
Lisp_Object arglist = args[0];
Lisp_Object instructions = args[1];
Lisp_Object constants = args[2];
- Lisp_Object stack_depth = args[3];
+ Lisp_Object stack_size = args[3];
Lisp_Object doc_string = (nargs > 4) ? args[4] : Qnil;
Lisp_Object interactive = (nargs > 5) ? args[5] : Qunbound;
-
- if (nargs < 4 || nargs > 6)
+ /* Don't purecopy the doc references in instructions because it's
+ wasteful; they will get fixed up later.
+
+ #### If something goes wrong and they don't get fixed up,
+ we're screwed, because pure stuff isn't marked and thus the
+ cons references won't be marked and will get reused.
+
+ Note: there will be a window after the byte code is created and
+ before the doc references are fixed up in which there will be
+ impure objects inside a pure object, which apparently won't
+ get marked, leading the trouble. But during that entire window,
+ the objects are sitting on Vload_force_doc_string_list, which
+ is staticpro'd, so we're OK. */
+ int purecopy_instructions = 1;
+
+ if (nargs > 6)
return Fsignal (Qwrong_number_of_arguments,
list2 (intern ("make-byte-code"), make_int (nargs)));
- /* Check for valid formal parameter list now, to allow us to use
- SPECBIND_FAST_UNSAFE() later in funcall_compiled_function(). */
- {
- Lisp_Object symbol, tail;
- EXTERNAL_LIST_LOOP_3 (symbol, arglist, tail)
- {
- CHECK_SYMBOL (symbol);
- if (EQ (symbol, Qt) ||
- EQ (symbol, Qnil) ||
- SYMBOL_IS_KEYWORD (symbol))
- signal_simple_error_2
- ("Invalid constant symbol in formal parameter list",
- symbol, arglist);
- }
- }
- f->arglist = arglist;
-
- /* `instructions' is a string or a cons (string . int) for a
+ CHECK_LIST (arglist);
+ /* instructions is a string or a cons (string . int) for a
lazy-loaded function. */
if (CONSP (instructions))
{
CHECK_STRING (XCAR (instructions));
CHECK_INT (XCDR (instructions));
+ if (!NILP (constants))
+ CHECK_VECTOR (constants);
+ purecopy_instructions = 0;
}
else
{
CHECK_STRING (instructions);
+ CHECK_VECTOR (constants);
}
- f->instructions = instructions;
+ CHECK_NATNUM (stack_size);
+ /* doc_string may be nil, string, int, or a cons (string . int). */
- if (!NILP (constants))
- CHECK_VECTOR (constants);
- f->constants = constants;
+ /* interactive may be list or string (or unbound). */
- CHECK_NATNUM (stack_depth);
- f->stack_depth = XINT (stack_depth);
-
-#ifdef COMPILED_FUNCTION_ANNOTATION_HACK
- if (!NILP (Vcurrent_compiled_function_annotation))
- f->annotated = Fcopy (Vcurrent_compiled_function_annotation);
- else if (!NILP (Vload_file_name_internal_the_purecopy))
- f->annotated = Vload_file_name_internal_the_purecopy;
- else if (!NILP (Vload_file_name_internal))
+ if (purify_flag)
{
- struct gcpro gcpro1;
- GCPRO1 (fun); /* don't let fun get reaped */
- Vload_file_name_internal_the_purecopy =
- Ffile_name_nondirectory (Vload_file_name_internal);
- f->annotated = Vload_file_name_internal_the_purecopy;
- UNGCPRO;
+ if (!purified (arglist))
+ arglist = Fpurecopy (arglist);
+ if (purecopy_instructions && !purified (instructions))
+ instructions = Fpurecopy (instructions);
+ if (!purified (doc_string))
+ doc_string = Fpurecopy (doc_string);
+ if (!purified (interactive) && !UNBOUNDP (interactive))
+ interactive = Fpurecopy (interactive);
+
+ /* Statistics are kept differently for the constants */
+ if (!purified (constants))
+#ifdef PURESTAT
+ {
+ int old = purecopying_for_bytecode;
+ purecopying_for_bytecode = 1;
+ constants = Fpurecopy (constants);
+ purecopying_for_bytecode = old;
+ }
+#else
+ constants = Fpurecopy (constants);
+#endif /* PURESTAT */
+
+#ifdef PURESTAT
+ if (STRINGP (instructions))
+ bump_purestat (&purestat_string_bytecodes, pure_sizeof (instructions));
+ if (VECTORP (constants))
+ bump_purestat (&purestat_vector_bytecode_constants,
+ pure_sizeof (constants));
+ if (STRINGP (doc_string))
+ /* These should be have been snagged by make-docfile... */
+ bump_purestat (&purestat_string_documentation,
+ pure_sizeof (doc_string));
+ if (STRINGP (interactive))
+ bump_purestat (&purestat_string_interactive,
+ pure_sizeof (interactive));
+#endif /* PURESTAT */
}
+
+ {
+ int docp = !NILP (doc_string);
+ int intp = !UNBOUNDP (interactive);
+#ifdef I18N3
+ int domp = !NILP (Vfile_domain);
+#endif
+ Lisp_Object val = make_compiled_function (purify_flag);
+ struct Lisp_Compiled_Function *b = XCOMPILED_FUNCTION (val);
+ b->flags.documentationp = docp;
+ b->flags.interactivep = intp;
+#ifdef I18N3
+ b->flags.domainp = domp;
+#endif
+ b->maxdepth = XINT (stack_size);
+ b->bytecodes = instructions;
+ b->constants = constants;
+ b->arglist = arglist;
+#ifdef COMPILED_FUNCTION_ANNOTATION_HACK
+ if (!NILP (Vcurrent_compiled_function_annotation))
+ b->annotated = Fpurecopy (Vcurrent_compiled_function_annotation);
+ else if (!NILP (Vload_file_name_internal_the_purecopy))
+ b->annotated = Vload_file_name_internal_the_purecopy;
+ else if (!NILP (Vload_file_name_internal))
+ {
+ struct gcpro gcpro1;
+ GCPRO1(val); /* don't let val or b get reaped */
+ Vload_file_name_internal_the_purecopy =
+ Fpurecopy (Ffile_name_nondirectory (Vload_file_name_internal));
+ b->annotated = Vload_file_name_internal_the_purecopy;
+ UNGCPRO;
+ }
#endif /* COMPILED_FUNCTION_ANNOTATION_HACK */
- /* doc_string may be nil, string, int, or a cons (string . int).
- interactive may be list or string (or unbound). */
- f->doc_and_interactive = Qunbound;
#ifdef I18N3
- if ((f->flags.domainp = !NILP (Vfile_domain)) != 0)
- f->doc_and_interactive = Vfile_domain;
+ if (docp && intp && domp)
+ b->doc_and_interactive = (((purify_flag) ? pure_cons : Fcons)
+ (doc_string,
+ (((purify_flag) ? pure_cons : Fcons)
+ (interactive, Vfile_domain))));
+ else if (docp && domp)
+ b->doc_and_interactive = (((purify_flag) ? pure_cons : Fcons)
+ (doc_string, Vfile_domain));
+ else if (intp && domp)
+ b->doc_and_interactive = (((purify_flag) ? pure_cons : Fcons)
+ (interactive, Vfile_domain));
+ else
#endif
- if ((f->flags.interactivep = !UNBOUNDP (interactive)) != 0)
- {
- f->doc_and_interactive
- = (UNBOUNDP (f->doc_and_interactive) ? interactive :
- Fcons (interactive, f->doc_and_interactive));
- }
- if ((f->flags.documentationp = !NILP (doc_string)) != 0)
- {
- f->doc_and_interactive
- = (UNBOUNDP (f->doc_and_interactive) ? doc_string :
- Fcons (doc_string, f->doc_and_interactive));
- }
- if (UNBOUNDP (f->doc_and_interactive))
- f->doc_and_interactive = Qnil;
+ if (docp && intp)
+ b->doc_and_interactive = (((purify_flag) ? pure_cons : Fcons)
+ (doc_string, interactive));
+ else if (intp)
+ b->doc_and_interactive = interactive;
+#ifdef I18N3
+ else if (domp)
+ b->doc_and_interactive = Vfile_domain;
+#endif
+ else
+ b->doc_and_interactive = doc_string;
- return fun;
+ return val;
+ }
}
\f
-/************************************************************************/
-/* Symbol allocation */
-/************************************************************************/
+/**********************************************************************/
+/* Symbol allocation */
+/**********************************************************************/
DECLARE_FIXED_TYPE_ALLOC (symbol, struct Lisp_Symbol);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_symbol 1000
Return a newly allocated uninterned symbol whose name is NAME.
Its value and function definition are void, and its property list is nil.
*/
- (name))
+ (str))
{
Lisp_Object val;
struct Lisp_Symbol *p;
- CHECK_STRING (name);
+ CHECK_STRING (str);
ALLOCATE_FIXED_TYPE (symbol, struct Lisp_Symbol, p);
- set_lheader_implementation (&(p->lheader), &lrecord_symbol);
- p->name = XSTRING (name);
- p->plist = Qnil;
- p->value = Qunbound;
+#ifdef LRECORD_SYMBOL
+ set_lheader_implementation (&(p->lheader), lrecord_symbol);
+#endif
+ p->name = XSTRING (str);
+ p->plist = Qnil;
+ p->value = Qunbound;
p->function = Qunbound;
+ p->obarray = Qnil;
symbol_next (p) = 0;
XSETSYMBOL (val, p);
return val;
}
\f
-/************************************************************************/
-/* Extent allocation */
-/************************************************************************/
+/**********************************************************************/
+/* Extent allocation */
+/**********************************************************************/
DECLARE_FIXED_TYPE_ALLOC (extent, struct extent);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_extent 1000
struct extent *e;
ALLOCATE_FIXED_TYPE (extent, struct extent, e);
- set_lheader_implementation (&(e->lheader), &lrecord_extent);
+ /* xzero (*e); */
+ set_lheader_implementation (&(e->lheader), lrecord_extent);
extent_object (e) = Qnil;
set_extent_start (e, -1);
set_extent_end (e, -1);
}
\f
-/************************************************************************/
-/* Event allocation */
-/************************************************************************/
+/**********************************************************************/
+/* Event allocation */
+/**********************************************************************/
DECLARE_FIXED_TYPE_ALLOC (event, struct Lisp_Event);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_event 1000
struct Lisp_Event *e;
ALLOCATE_FIXED_TYPE (event, struct Lisp_Event, e);
- set_lheader_implementation (&(e->lheader), &lrecord_event);
+ set_lheader_implementation (&(e->lheader), lrecord_event);
XSETEVENT (val, e);
return val;
}
\f
-/************************************************************************/
-/* Marker allocation */
-/************************************************************************/
+/**********************************************************************/
+/* Marker allocation */
+/**********************************************************************/
DECLARE_FIXED_TYPE_ALLOC (marker, struct Lisp_Marker);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_marker 1000
struct Lisp_Marker *p;
ALLOCATE_FIXED_TYPE (marker, struct Lisp_Marker, p);
- set_lheader_implementation (&(p->lheader), &lrecord_marker);
+ set_lheader_implementation (&(p->lheader), lrecord_marker);
p->buffer = 0;
p->memind = 0;
marker_next (p) = 0;
struct Lisp_Marker *p;
NOSEEUM_ALLOCATE_FIXED_TYPE (marker, struct Lisp_Marker, p);
- set_lheader_implementation (&(p->lheader), &lrecord_marker);
+ set_lheader_implementation (&(p->lheader), lrecord_marker);
p->buffer = 0;
p->memind = 0;
marker_next (p) = 0;
}
\f
-/************************************************************************/
-/* String allocation */
-/************************************************************************/
+/**********************************************************************/
+/* String allocation */
+/**********************************************************************/
/* The data for "short" strings generally resides inside of structs of type
string_chars_block. The Lisp_String structure is allocated just like any
/* #define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_string 10000 */
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_string 1000
+#ifdef LRECORD_STRING
static Lisp_Object
-mark_string (Lisp_Object obj)
+mark_string (Lisp_Object obj, void (*markobj) (Lisp_Object))
{
struct Lisp_String *ptr = XSTRING (obj);
- if (CONSP (ptr->plist) && EXTENT_INFOP (XCAR (ptr->plist)))
+ if (GC_CONSP (ptr->plist) && GC_EXTENT_INFOP (XCAR (ptr->plist)))
flush_cached_extent_info (XCAR (ptr->plist));
return ptr->plist;
}
static int
-string_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
+string_equal (Lisp_Object o1, Lisp_Object o2, int depth)
{
Bytecount len;
- return (((len = XSTRING_LENGTH (obj1)) == XSTRING_LENGTH (obj2)) &&
- !memcmp (XSTRING_DATA (obj1), XSTRING_DATA (obj2), len));
+ return (((len = XSTRING_LENGTH (o1)) == XSTRING_LENGTH (o2)) &&
+ !memcmp (XSTRING_DATA (o1), XSTRING_DATA (o2), len));
}
-static const struct lrecord_description string_description[] = {
- { XD_BYTECOUNT, offsetof(Lisp_String, size) },
- { XD_OPAQUE_DATA_PTR, offsetof(Lisp_String, data), XD_INDIRECT(0, 1) },
- { XD_LISP_OBJECT, offsetof(Lisp_String, plist), 1 },
- { XD_END }
-};
-
DEFINE_BASIC_LRECORD_IMPLEMENTATION ("string", string,
mark_string, print_string,
/*
* SWEEP_FIXED_TYPE_BLOCK().
*/
0, string_equal, 0,
- string_description,
struct Lisp_String);
+#endif /* LRECORD_STRING */
/* String blocks contain this many useful bytes. */
#define STRING_CHARS_BLOCK_SIZE \
unsigned char string_chars[STRING_CHARS_BLOCK_SIZE];
};
-static struct string_chars_block *first_string_chars_block;
-static struct string_chars_block *current_string_chars_block;
+struct string_chars_block *first_string_chars_block;
+struct string_chars_block *current_string_chars_block;
/* If SIZE is the length of a string, this returns how many bytes
* the string occupies in string_chars_block->string_chars
else
{
/* Make a new current string chars block */
- struct string_chars_block *new_scb = xnew (struct string_chars_block);
+ struct string_chars_block *new = xnew (struct string_chars_block);
- current_string_chars_block->next = new_scb;
- new_scb->prev = current_string_chars_block;
- new_scb->next = 0;
- current_string_chars_block = new_scb;
- new_scb->pos = fullsize;
+ current_string_chars_block->next = new;
+ new->prev = current_string_chars_block;
+ new->next = 0;
+ current_string_chars_block = new;
+ new->pos = fullsize;
s_chars = (struct string_chars *)
current_string_chars_block->string_chars;
}
/* Allocate the string header */
ALLOCATE_FIXED_TYPE (string, struct Lisp_String, s);
- set_lheader_implementation (&(s->lheader), &lrecord_string);
+#ifdef LRECORD_STRING
+ set_lheader_implementation (&(s->lheader), lrecord_string);
+#endif
s_chars = allocate_string_chars_struct (s, fullsize);
void
set_string_char (struct Lisp_String *s, Charcount i, Emchar c)
{
+ Bytecount oldlen, newlen;
Bufbyte newstr[MAX_EMCHAR_LEN];
Bytecount bytoff = charcount_to_bytecount (string_data (s), i);
- Bytecount oldlen = charcount_to_bytecount (string_data (s) + bytoff, 1);
- Bytecount newlen = set_charptr_emchar (newstr, c);
+
+ oldlen = charcount_to_bytecount (string_data (s) + bytoff, 1);
+ newlen = set_charptr_emchar (newstr, c);
if (oldlen != newlen)
resize_string (s, bytoff, newlen - oldlen);
*/
(length, init))
{
+ Lisp_Object val;
+
CHECK_NATNUM (length);
CHECK_CHAR_COERCE_INT (init);
{
- Bufbyte init_str[MAX_EMCHAR_LEN];
- int len = set_charptr_emchar (init_str, XCHAR (init));
- Lisp_Object val = make_uninit_string (len * XINT (length));
+ Bufbyte str[MAX_EMCHAR_LEN];
+ int len = set_charptr_emchar (str, XCHAR (init));
+ val = make_uninit_string (len * XINT (length));
if (len == 1)
/* Optimize the single-byte case */
memset (XSTRING_DATA (val), XCHAR (init), XSTRING_LENGTH (val));
else
{
- size_t i;
+ int i, j, k;
Bufbyte *ptr = XSTRING_DATA (val);
- for (i = XINT (length); i; i--)
- {
- Bufbyte *init_ptr = init_str;
- switch (len)
- {
- case 4: *ptr++ = *init_ptr++;
- case 3: *ptr++ = *init_ptr++;
- case 2: *ptr++ = *init_ptr++;
- case 1: *ptr++ = *init_ptr++;
- }
- }
+ k = 0;
+ for (i = 0; i < XINT (length); i++)
+ for (j = 0; j < len; j++)
+ ptr[k++] = str[j];
}
- return val;
}
+ return val;
}
DEFUN ("string", Fstring, 0, MANY, 0, /*
return make_string (storage, p - storage);
}
-
/* Take some raw memory, which MUST already be in internal format,
and package it up into a Lisp string. */
Lisp_Object
return build_string (GETTEXT (str));
}
-Lisp_Object
-make_string_nocopy (CONST Bufbyte *contents, Bytecount length)
-{
- struct Lisp_String *s;
- Lisp_Object val;
-
- /* Make sure we find out about bad make_string_nocopy's when they happen */
-#if defined (ERROR_CHECK_BUFPOS) && defined (MULE)
- bytecount_to_charcount (contents, length); /* Just for the assertions */
-#endif
-
- /* Allocate the string header */
- ALLOCATE_FIXED_TYPE (string, struct Lisp_String, s);
- set_lheader_implementation (&(s->lheader), &lrecord_string);
- SET_C_READONLY_RECORD_HEADER (&s->lheader);
- s->plist = Qnil;
- set_string_data (s, (Bufbyte *)contents);
- set_string_length (s, length);
-
- XSETSTRING (val, s);
- return val;
-}
-
-\f
-/************************************************************************/
-/* lcrecord lists */
-/************************************************************************/
+\f
+/************************************************************************/
+/* lcrecord lists */
+/************************************************************************/
/* Lcrecord lists are used to manage the allocation of particular
sorts of lcrecords, to avoid calling alloc_lcrecord() (and thus
It works like this:
1) Create an lcrecord-list object using make_lcrecord_list().
- This is often done at initialization. Remember to staticpro_nodump
+ This is often done at initialization. Remember to staticpro
this object! The arguments to make_lcrecord_list() are the
same as would be passed to alloc_lcrecord().
2) Instead of calling alloc_lcrecord(), call allocate_managed_lcrecord()
*/
static Lisp_Object
-mark_lcrecord_list (Lisp_Object obj)
+mark_lcrecord_list (Lisp_Object obj, void (*markobj) (Lisp_Object))
{
struct lcrecord_list *list = XLCRECORD_LIST (obj);
Lisp_Object chain = list->free;
DEFINE_LRECORD_IMPLEMENTATION ("lcrecord-list", lcrecord_list,
mark_lcrecord_list, internal_object_printer,
- 0, 0, 0, 0, struct lcrecord_list);
+ 0, 0, 0, struct lcrecord_list);
Lisp_Object
make_lcrecord_list (size_t size,
CONST struct lrecord_implementation *implementation)
{
struct lcrecord_list *p = alloc_lcrecord_type (struct lcrecord_list,
- &lrecord_lcrecord_list);
+ lrecord_lcrecord_list);
Lisp_Object val;
p->implementation = implementation;
/* Make sure the size is correct. This will catch, for example,
putting a window configuration on the wrong free list. */
if (implementation->size_in_bytes_method)
- assert (implementation->size_in_bytes_method (lheader) == list->size);
+ assert (((implementation->size_in_bytes_method) (lheader))
+ == list->size);
else
assert (implementation->static_size == list->size);
#endif /* ERROR_CHECK_GC */
if (implementation->finalizer)
- implementation->finalizer (lheader, 0);
+ ((implementation->finalizer) (lheader, 0));
free_header->chain = list->free;
free_header->lcheader.free = 1;
list->free = lcrecord;
}
\f
+/**********************************************************************/
+/* Purity of essence, peace on earth */
+/**********************************************************************/
-\f
-DEFUN ("purecopy", Fpurecopy, 1, 1, 0, /*
-Kept for compatibility, returns its argument.
-Old:
-Make a copy of OBJECT in pure storage.
-Recursively copies contents of vectors and cons cells.
-Does not copy symbols.
-*/
- (obj))
-{
- return obj;
-}
+static int symbols_initialized;
+Lisp_Object
+make_pure_string (CONST Bufbyte *data, Bytecount length,
+ Lisp_Object plist, int no_need_to_copy_data)
+{
+ Lisp_Object new;
+ struct Lisp_String *s;
+ size_t size = sizeof (struct Lisp_String) +
+ (no_need_to_copy_data ? 0 : (length + 1)); /* + 1 for terminating 0 */
+ size = ALIGN_SIZE (size, ALIGNOF (Lisp_Object));
-\f
-/************************************************************************/
-/* Garbage Collection */
-/************************************************************************/
+ if (symbols_initialized && !pure_lossage)
+ {
+ /* Try to share some names. Saves a few kbytes. */
+ Lisp_Object tem = oblookup (Vobarray, data, length);
+ if (SYMBOLP (tem))
+ {
+ s = XSYMBOL (tem)->name;
+ if (!PURIFIED (s)) abort ();
+ XSETSTRING (new, s);
+ return new;
+ }
+ }
-/* This will be used more extensively In The Future */
-static int last_lrecord_type_index_assigned;
+ if (!check_purespace (size))
+ return make_string (data, length);
-CONST struct lrecord_implementation *lrecord_implementations_table[128];
-#define max_lrecord_type (countof (lrecord_implementations_table) - 1)
+ s = (struct Lisp_String *) (PUREBEG + pure_bytes_used);
+#ifdef LRECORD_STRING
+ set_lheader_implementation (&(s->lheader), lrecord_string);
+#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
+ s->lheader.pure = 1;
+#endif
+#endif
+ set_string_length (s, length);
+ if (no_need_to_copy_data)
+ {
+ set_string_data (s, (Bufbyte *) data);
+ }
+ else
+ {
+ set_string_data (s, (Bufbyte *) s + sizeof (struct Lisp_String));
+ memcpy (string_data (s), data, length);
+ set_string_byte (s, length, 0);
+ }
+ s->plist = Qnil;
+ pure_bytes_used += size;
-struct gcpro *gcprolist;
+#ifdef PURESTAT
+ bump_purestat (&purestat_string_all, size);
+ if (purecopying_for_bytecode)
+ bump_purestat (&purestat_string_other_function, size);
+#endif /* PURESTAT */
-/* 415 used Mly 29-Jun-93 */
-/* 1327 used slb 28-Feb-98 */
-/* 1328 used og 03-Oct-99 (moving slowly, heh?) */
-#ifdef HAVE_SHLIB
-#define NSTATICS 4000
-#else
-#define NSTATICS 2000
-#endif
-/* Not "static" because of linker lossage on some systems */
-Lisp_Object *staticvec[NSTATICS]
- /* Force it into data space! */
- = {0};
-static int staticidx;
+ /* Do this after the official "completion" of the purecopying. */
+ s->plist = Fpurecopy (plist);
-/* Put an entry in staticvec, pointing at the variable whose address is given
- */
-void
-staticpro (Lisp_Object *varaddress)
-{
- if (staticidx >= countof (staticvec))
- /* #### This is now a dubious abort() since this routine may be called */
- /* by Lisp attempting to load a DLL. */
- abort ();
- staticvec[staticidx++] = varaddress;
+ XSETSTRING (new, s);
+ return new;
}
-/* Not "static" because of linker lossage on some systems */
-Lisp_Object *staticvec_nodump[200]
- /* Force it into data space! */
- = {0};
-static int staticidx_nodump;
-/* Put an entry in staticvec_nodump, pointing at the variable whose address is given
- */
-void
-staticpro_nodump (Lisp_Object *varaddress)
+Lisp_Object
+make_pure_pname (CONST Bufbyte *data, Bytecount length,
+ int no_need_to_copy_data)
{
- if (staticidx_nodump >= countof (staticvec_nodump))
- /* #### This is now a dubious abort() since this routine may be called */
- /* by Lisp attempting to load a DLL. */
- abort ();
- staticvec_nodump[staticidx_nodump++] = varaddress;
-}
+ Lisp_Object name = make_pure_string (data, length, Qnil,
+ no_need_to_copy_data);
+ bump_purestat (&purestat_string_pname, pure_sizeof (name));
-/* Not "static" because of linker lossage on some systems */
-struct {
- void *data;
- const struct struct_description *desc;
-} dumpstructvec[200];
-
-static int dumpstructidx;
+ /* We've made (at least) Qnil now, and Vobarray will soon be set up. */
+ symbols_initialized = 1;
-/* Put an entry in dumpstructvec, pointing at the variable whose address is given
- */
-void
-dumpstruct (void *varaddress, const struct struct_description *desc)
-{
- if (dumpstructidx >= countof (dumpstructvec))
- abort ();
- dumpstructvec[dumpstructidx].data = varaddress;
- dumpstructvec[dumpstructidx].desc = desc;
- dumpstructidx++;
+ return name;
}
-Lisp_Object *pdump_wirevec[50];
-static int pdump_wireidx;
-/* Put an entry in pdump_wirevec, pointing at the variable whose address is given
- */
-void
-pdump_wire (Lisp_Object *varaddress)
+Lisp_Object
+pure_cons (Lisp_Object car, Lisp_Object cdr)
{
- if (pdump_wireidx >= countof (pdump_wirevec))
- abort ();
- pdump_wirevec[pdump_wireidx++] = varaddress;
-}
+ Lisp_Object new;
+ struct Lisp_Cons *c;
+ if (!check_purespace (sizeof (struct Lisp_Cons)))
+ return Fcons (Fpurecopy (car), Fpurecopy (cdr));
-Lisp_Object *pdump_wirevec_list[50];
-static int pdump_wireidx_list;
+ c = (struct Lisp_Cons *) (PUREBEG + pure_bytes_used);
+#ifdef LRECORD_CONS
+ set_lheader_implementation (&(c->lheader), lrecord_cons);
+#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
+ c->lheader.pure = 1;
+#endif
+#endif
+ pure_bytes_used += sizeof (struct Lisp_Cons);
+ bump_purestat (&purestat_cons, sizeof (struct Lisp_Cons));
-/* Put an entry in pdump_wirevec_list, pointing at the variable whose address is given
- */
-void
-pdump_wire_list (Lisp_Object *varaddress)
+ c->car = Fpurecopy (car);
+ c->cdr = Fpurecopy (cdr);
+ XSETCONS (new, c);
+ return new;
+}
+
+Lisp_Object
+pure_list (int nargs, Lisp_Object *args)
{
- if (pdump_wireidx_list >= countof (pdump_wirevec_list))
- abort ();
- pdump_wirevec_list[pdump_wireidx_list++] = varaddress;
+ Lisp_Object val = Qnil;
+
+ for (--nargs; nargs >= 0; nargs--)
+ val = pure_cons (args[nargs], val);
+
+ return val;
}
-\f
-/* Mark reference to a Lisp_Object. If the object referred to has not been
- seen yet, recursively mark all the references contained in it. */
+#ifdef LISP_FLOAT_TYPE
-void
-mark_object (Lisp_Object obj)
+static Lisp_Object
+make_pure_float (double num)
{
- tail_recurse:
+ struct Lisp_Float *f;
+ Lisp_Object val;
-#ifdef ERROR_CHECK_GC
- assert (! (EQ (obj, Qnull_pointer)));
-#endif
- /* Checks we used to perform */
- /* if (EQ (obj, Qnull_pointer)) return; */
- /* if (!POINTER_TYPE_P (XGCTYPE (obj))) return; */
- /* if (PURIFIED (XPNTR (obj))) return; */
+ /* Make sure that PUREBEG + pure_bytes_used is aligned on at least a sizeof
+ (double) boundary. Some architectures (like the sparc) require
+ this, and I suspect that floats are rare enough that it's no
+ tragedy for those that don't. */
+ {
+#if defined (__GNUC__) && (__GNUC__ >= 2)
+ /* In gcc, we can directly ask what the alignment constraints of a
+ structure are, but in general, that's not possible... Arrgh!!
+ */
+ int alignment = __alignof (struct Lisp_Float);
+#else /* !GNUC */
+ /* Best guess is to make the `double' slot be aligned to the size
+ of double (which is probably 8 bytes). This assumes that it's
+ ok to align the beginning of the structure to the same boundary
+ that the `double' slot in it is supposed to be aligned to; this
+ should be ok because presumably there is padding in the layout
+ of the struct to account for this.
+ */
+ int alignment = sizeof (float_data (f));
+#endif /* !GNUC */
+ char *p = ((char *) PUREBEG + pure_bytes_used);
+
+ p = (char *) (((EMACS_UINT) p + alignment - 1) & - alignment);
+ pure_bytes_used = p - (char *) PUREBEG;
+ }
- if (XTYPE (obj) == Lisp_Type_Record)
- {
- struct lrecord_header *lheader = XRECORD_LHEADER (obj);
-#if defined (ERROR_CHECK_GC)
- assert (lheader->type <= last_lrecord_type_index_assigned);
-#endif
- if (C_READONLY_RECORD_HEADER_P (lheader))
- return;
+ if (!check_purespace (sizeof (struct Lisp_Float)))
+ return make_float (num);
- if (! MARKED_RECORD_HEADER_P (lheader) &&
- ! UNMARKABLE_RECORD_HEADER_P (lheader))
- {
- CONST struct lrecord_implementation *implementation =
- LHEADER_IMPLEMENTATION (lheader);
- MARK_RECORD_HEADER (lheader);
-#ifdef ERROR_CHECK_GC
- if (!implementation->basic_p)
- assert (! ((struct lcrecord_header *) lheader)->free);
+ f = (struct Lisp_Float *) (PUREBEG + pure_bytes_used);
+ set_lheader_implementation (&(f->lheader), lrecord_float);
+#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
+ f->lheader.pure = 1;
#endif
- if (implementation->marker)
- {
- obj = implementation->marker (obj);
- if (!NILP (obj)) goto tail_recurse;
- }
- }
- }
+ pure_bytes_used += sizeof (struct Lisp_Float);
+ bump_purestat (&purestat_float, sizeof (struct Lisp_Float));
+
+ float_data (f) = num;
+ XSETFLOAT (val, f);
+ return val;
}
-/* mark all of the conses in a list and mark the final cdr; but
- DO NOT mark the cars.
+#endif /* LISP_FLOAT_TYPE */
- Use only for internal lists! There should never be other pointers
- to the cons cells, because if so, the cars will remain unmarked
- even when they maybe should be marked. */
-void
-mark_conses_in_list (Lisp_Object obj)
+Lisp_Object
+make_pure_vector (size_t len, Lisp_Object init)
{
- Lisp_Object rest;
+ Lisp_Object new;
+ struct Lisp_Vector *v;
+ size_t size = (sizeof (struct Lisp_Vector)
+ + (len - 1) * sizeof (Lisp_Object));
- for (rest = obj; CONSP (rest); rest = XCDR (rest))
- {
- if (CONS_MARKED_P (XCONS (rest)))
- return;
- MARK_CONS (XCONS (rest));
- }
+ init = Fpurecopy (init);
- mark_object (rest);
-}
+ if (!check_purespace (size))
+ return make_vector (len, init);
-\f
-/* Find all structures not marked, and free them. */
+ v = (struct Lisp_Vector *) (PUREBEG + pure_bytes_used);
+#ifdef LRECORD_VECTOR
+ set_lheader_implementation (&(v->header.lheader), lrecord_vector);
+#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
+ v->header.lheader.pure = 1;
+#endif
+#endif
+ pure_bytes_used += size;
+ bump_purestat (&purestat_vector_all, size);
-static int gc_count_num_bit_vector_used, gc_count_bit_vector_total_size;
-static int gc_count_bit_vector_storage;
-static int gc_count_num_short_string_in_use;
-static int gc_count_string_total_size;
-static int gc_count_short_string_total_size;
+ v->size = len;
-/* static int gc_count_total_records_used, gc_count_records_total_size; */
+ for (size = 0; size < len; size++)
+ v->contents[size] = init;
-\f
-int
-lrecord_type_index (CONST struct lrecord_implementation *implementation)
+ XSETVECTOR (new, v);
+ return new;
+}
+
+#if 0
+/* Presently unused */
+void *
+alloc_pure_lrecord (int size, struct lrecord_implementation *implementation)
{
- int type_index = *(implementation->lrecord_type_index);
- /* Have to do this circuitous validation test because of problems
- dumping out initialized variables (ie can't set xxx_type_index to -1
- because that would make xxx_type_index read-only in a dumped emacs. */
- if (type_index < 0 || type_index > max_lrecord_type
- || lrecord_implementations_table[type_index] != implementation)
- {
- assert (last_lrecord_type_index_assigned < max_lrecord_type);
- type_index = ++last_lrecord_type_index_assigned;
- lrecord_implementations_table[type_index] = implementation;
- *(implementation->lrecord_type_index) = type_index;
- }
- return type_index;
+ struct lrecord_header *header = (void *) (PUREBEG + pure_bytes_used);
+
+ if (pure_bytes_used + size > get_PURESIZE())
+ pure_storage_exhausted ();
+
+ set_lheader_implementation (header, implementation);
+ header->next = 0;
+ return header;
}
+#endif /* unused */
-/* stats on lcrecords in use - kinda kludgy */
-static struct
+\f
+DEFUN ("purecopy", Fpurecopy, 1, 1, 0, /*
+Make a copy of OBJECT in pure storage.
+Recursively copies contents of vectors and cons cells.
+Does not copy symbols.
+*/
+ (obj))
{
- int instances_in_use;
- int bytes_in_use;
- int instances_freed;
- int bytes_freed;
- int instances_on_free_list;
-} lcrecord_stats [countof (lrecord_implementations_table)];
+ int i;
+ if (!purify_flag)
+ return obj;
-static void
-tick_lcrecord_stats (CONST struct lrecord_header *h, int free_p)
-{
- CONST struct lrecord_implementation *implementation =
- LHEADER_IMPLEMENTATION (h);
- int type_index = lrecord_type_index (implementation);
+ if (!POINTER_TYPE_P (XTYPE (obj))
+ || PURIFIED (XPNTR (obj))
+ /* happens when bootstrapping Qnil */
+ || EQ (obj, Qnull_pointer))
+ return obj;
- if (((struct lcrecord_header *) h)->free)
- {
- assert (!free_p);
- lcrecord_stats[type_index].instances_on_free_list++;
- }
- else
+ switch (XTYPE (obj))
{
- size_t sz = (implementation->size_in_bytes_method
- ? implementation->size_in_bytes_method (h)
- : implementation->static_size);
+#ifndef LRECORD_CONS
+ case Lisp_Type_Cons:
+ return pure_cons (XCAR (obj), XCDR (obj));
+#endif
- if (free_p)
+#ifndef LRECORD_STRING
+ case Lisp_Type_String:
+ return make_pure_string (XSTRING_DATA (obj),
+ XSTRING_LENGTH (obj),
+ XSTRING (obj)->plist,
+ 0);
+#endif /* ! LRECORD_STRING */
+
+#ifndef LRECORD_VECTOR
+ case Lisp_Type_Vector:
+ {
+ struct Lisp_Vector *o = XVECTOR (obj);
+ Lisp_Object new = make_pure_vector (vector_length (o), Qnil);
+ for (i = 0; i < vector_length (o); i++)
+ XVECTOR_DATA (new)[i] = Fpurecopy (o->contents[i]);
+ return new;
+ }
+#endif /* !LRECORD_VECTOR */
+
+ default:
+ {
+ if (COMPILED_FUNCTIONP (obj))
+ {
+ struct Lisp_Compiled_Function *o = XCOMPILED_FUNCTION (obj);
+ Lisp_Object new = make_compiled_function (1);
+ /* How on earth could this code have worked before? -sb */
+ struct Lisp_Compiled_Function *n = XCOMPILED_FUNCTION (new);
+ n->flags = o->flags;
+ n->bytecodes = Fpurecopy (o->bytecodes);
+ n->constants = Fpurecopy (o->constants);
+ n->arglist = Fpurecopy (o->arglist);
+ n->doc_and_interactive = Fpurecopy (o->doc_and_interactive);
+ n->maxdepth = o->maxdepth;
+ return new;
+ }
+#ifdef LRECORD_CONS
+ else if (CONSP (obj))
+ return pure_cons (XCAR (obj), XCDR (obj));
+#endif /* LRECORD_CONS */
+#ifdef LRECORD_VECTOR
+ else if (VECTORP (obj))
{
- lcrecord_stats[type_index].instances_freed++;
- lcrecord_stats[type_index].bytes_freed += sz;
+ struct Lisp_Vector *o = XVECTOR (obj);
+ Lisp_Object new = make_pure_vector (vector_length (o), Qnil);
+ for (i = 0; i < vector_length (o); i++)
+ XVECTOR_DATA (new)[i] = Fpurecopy (o->contents[i]);
+ return new;
}
- else
+#endif /* LRECORD_VECTOR */
+#ifdef LRECORD_STRING
+ else if (STRINGP (obj))
{
- lcrecord_stats[type_index].instances_in_use++;
- lcrecord_stats[type_index].bytes_in_use += sz;
+ return make_pure_string (XSTRING_DATA (obj),
+ XSTRING_LENGTH (obj),
+ XSTRING (obj)->plist,
+ 0);
}
+#endif /* LRECORD_STRING */
+#ifdef LISP_FLOAT_TYPE
+ else if (FLOATP (obj))
+ return make_pure_float (float_data (XFLOAT (obj)));
+#endif /* LISP_FLOAT_TYPE */
+ else if (SYMBOLP (obj))
+ {
+ /*
+ * Symbols can't be made pure (and thus read-only),
+ * because assigning to their function, value or plist
+ * slots would produced a SEGV in the dumped XEmacs. So
+ * we previously would just return the symbol unchanged.
+ *
+ * But purified aggregate objects like lists and vectors
+ * can contain uninterned symbols. If there are no
+ * other non-pure references to the symbol, then the
+ * symbol is not protected from garbage collection
+ * because the collector does not mark the contents of
+ * purified objects. So to protect the symbols, an impure
+ * reference has to be kept for each uninterned symbol
+ * that is referenced by a pure object. All such
+ * symbols are stored in the hashtable pointed to by
+ * Vpure_uninterned_symbol_table, which is itself
+ * staticpro'd.
+ */
+ if (!NILP (XSYMBOL (obj)->obarray))
+ return obj;
+ Fputhash (obj, Qnil, Vpure_uninterned_symbol_table);
+ return obj;
+ }
+ else
+ signal_simple_error ("Can't purecopy %S", obj);
+ }
}
+ return obj;
}
+
\f
-/* Free all unmarked records */
static void
-sweep_lcrecords_1 (struct lcrecord_header **prev, int *used)
+puresize_adjust_h (size_t puresize)
{
- struct lcrecord_header *header;
- int num_used = 0;
- /* int total_size = 0; */
+ FILE *stream = fopen ("puresize-adjust.h", "w");
- xzero (lcrecord_stats); /* Reset all statistics to 0. */
+ if (stream == NULL)
+ report_file_error ("Opening puresize adjustment file",
+ Fcons (build_string ("puresize-adjust.h"), Qnil));
- /* First go through and call all the finalize methods.
- Then go through and free the objects. There used to
- be only one loop here, with the call to the finalizer
- occurring directly before the xfree() below. That
- is marginally faster but much less safe -- if the
- finalize method for an object needs to reference any
- other objects contained within it (and many do),
- we could easily be screwed by having already freed that
- other object. */
+ fprintf (stream,
+ "/*\tDo not edit this file!\n"
+ "\tAutomatically generated by XEmacs */\n"
+ "# define PURESIZE_ADJUSTMENT (%ld)\n",
+ (long) (puresize - RAW_PURESIZE));
+ fclose (stream);
+}
- for (header = *prev; header; header = header->next)
+void
+report_pure_usage (int report_impurities,
+ int die_if_pure_storage_exceeded)
+{
+ int rc = 0;
+
+ if (pure_lossage)
{
- struct lrecord_header *h = &(header->lheader);
- if (!C_READONLY_RECORD_HEADER_P(h)
- && !MARKED_RECORD_HEADER_P (h)
- && ! (header->free))
+ message ("\n****\tPure Lisp storage exhausted!\n"
+ "\tPurespace usage: %ld of %ld\n"
+ "****",
+ (long) get_PURESIZE() + pure_lossage,
+ (long) get_PURESIZE());
+ if (die_if_pure_storage_exceeded)
{
- if (LHEADER_IMPLEMENTATION (h)->finalizer)
- LHEADER_IMPLEMENTATION (h)->finalizer (h, 0);
+ puresize_adjust_h (get_PURESIZE() + pure_lossage);
+#ifdef HEAP_IN_DATA
+ sheap_adjust_h();
+#endif
+ rc = -1;
}
}
-
- for (header = *prev; header; )
+ else
{
- struct lrecord_header *h = &(header->lheader);
- if (C_READONLY_RECORD_HEADER_P(h) || MARKED_RECORD_HEADER_P (h))
- {
- if (MARKED_RECORD_HEADER_P (h))
- UNMARK_RECORD_HEADER (h);
- num_used++;
- /* total_size += n->implementation->size_in_bytes (h);*/
- /* ### May modify header->next on a C_READONLY lcrecord */
- prev = &(header->next);
- header = *prev;
- tick_lcrecord_stats (h, 0);
- }
- else
- {
- struct lcrecord_header *next = header->next;
- *prev = next;
- tick_lcrecord_stats (h, 1);
- /* used to call finalizer right here. */
- xfree (header);
- header = next;
+ size_t lost = (get_PURESIZE() - pure_bytes_used) / 1024;
+ char buf[200];
+ /* extern Lisp_Object Vemacs_beta_version; */
+ /* This used to be NILP(Vemacs_beta_version) ? 512 : 4; */
+#ifndef PURESIZE_SLOP
+#define PURESIZE_SLOP 0
+#endif
+ size_t slop = PURESIZE_SLOP;
+
+ sprintf (buf, "Purespace usage: %ld of %ld (%d%%",
+ (long) pure_bytes_used,
+ (long) get_PURESIZE(),
+ (int) (pure_bytes_used / (get_PURESIZE() / 100.0) + 0.5));
+ if (lost > ((slop ? slop : 1) / 1024)) {
+ sprintf (buf + strlen (buf), " -- %ldk wasted", (long)lost);
+ if (die_if_pure_storage_exceeded) {
+ puresize_adjust_h (pure_bytes_used + slop);
+#ifdef HEAP_IN_DATA
+ sheap_adjust_h();
+#endif
+ rc = -1;
}
+ }
+
+ strcat (buf, ").");
+ message ("%s", buf);
}
- *used = num_used;
- /* *total = total_size; */
-}
+#ifdef PURESTAT
+
+ purestat_vector_other.nbytes =
+ purestat_vector_all.nbytes -
+ purestat_vector_bytecode_constants.nbytes;
+ purestat_vector_other.nobjects =
+ purestat_vector_all.nobjects -
+ purestat_vector_bytecode_constants.nobjects;
+
+ purestat_string_other.nbytes =
+ purestat_string_all.nbytes -
+ (purestat_string_pname.nbytes +
+ purestat_string_bytecodes.nbytes +
+ purestat_string_interactive.nbytes +
+ purestat_string_documentation.nbytes +
+#ifdef I18N3
+ purestat_string_domain.nbytes +
+#endif
+ purestat_string_other_function.nbytes);
+
+ purestat_string_other.nobjects =
+ purestat_string_all.nobjects -
+ (purestat_string_pname.nobjects +
+ purestat_string_bytecodes.nobjects +
+ purestat_string_interactive.nobjects +
+ purestat_string_documentation.nobjects +
+#ifdef I18N3
+ purestat_string_domain.nobjects +
+#endif
+ purestat_string_other_function.nobjects);
-static void
-sweep_bit_vectors_1 (Lisp_Object *prev,
- int *used, int *total, int *storage)
-{
- Lisp_Object bit_vector;
- int num_used = 0;
- int total_size = 0;
- int total_storage = 0;
+ message (" %-26s Total Bytes", "");
- /* BIT_VECTORP fails because the objects are marked, which changes
- their implementation */
- for (bit_vector = *prev; !EQ (bit_vector, Qzero); )
- {
- Lisp_Bit_Vector *v = XBIT_VECTOR (bit_vector);
- int len = v->size;
- if (C_READONLY_RECORD_HEADER_P(&(v->lheader)) || MARKED_RECORD_P (bit_vector))
+ {
+ int j;
+
+ for (j = 0; j < countof (purestats); j++)
+ if (!purestats[j])
+ clear_message ();
+ else
{
- if (MARKED_RECORD_P (bit_vector))
- UNMARK_RECORD_HEADER (&(v->lheader));
- total_size += len;
- total_storage +=
- MALLOC_OVERHEAD +
- STRETCHY_STRUCT_SIZEOF (Lisp_Bit_Vector, bits,
- BIT_VECTOR_LONG_STORAGE (len));
- num_used++;
- /* ### May modify next on a C_READONLY bitvector */
- prev = &(bit_vector_next (v));
- bit_vector = *prev;
+ char buf [100];
+ sprintf(buf, "%s:", purestats[j]->name);
+ message (" %-26s %5d %7d %2d%%",
+ buf,
+ purestats[j]->nobjects,
+ purestats[j]->nbytes,
+ (int) (purestats[j]->nbytes / (pure_bytes_used / 100.0) + 0.5));
}
- else
+ }
+#endif /* PURESTAT */
+
+
+ if (report_impurities)
+ {
+ Lisp_Object tem = Felt (Fgarbage_collect (), make_int (5));
+ struct gcpro gcpro1;
+ GCPRO1 (tem);
+ message ("\nImpurities:");
+ while (!NILP (tem))
{
- Lisp_Object next = bit_vector_next (v);
- *prev = next;
- xfree (v);
- bit_vector = next;
+ if (CONSP (tem) && SYMBOLP (Fcar (tem)) && CONSP (Fcdr (tem)))
+ {
+ int total = XINT (Fcar (Fcdr (tem)));
+ if (total > 0)
+ {
+ char buf [100];
+ char *s = buf;
+ memcpy (buf, string_data (XSYMBOL (Fcar (tem))->name),
+ string_length (XSYMBOL (Fcar (tem))->name) + 1);
+ while (*s++) if (*s == '-') *s = ' ';
+ s--; *s++ = ':'; *s = 0;
+ message (" %-33s %6d", buf, total);
+ }
+ tem = Fcdr (Fcdr (tem));
+ }
+ else /* WTF?! */
+ {
+ Fprin1 (tem, Qexternal_debugging_output);
+ tem = Qnil;
+ }
}
+ UNGCPRO;
+ garbage_collect_1 (); /* GC garbage_collect's garbage */
}
- *used = num_used;
- *total = total_size;
- *storage = total_storage;
-}
-
-/* And the Lord said: Thou shalt use the `c-backslash-region' command
- to make macros prettier. */
+ clear_message ();
-#ifdef ERROR_CHECK_GC
+ if (rc < 0) {
+ unlink("SATISFIED");
+ fatal ("Pure size adjusted, Don't Panic! I will restart the `make'");
+ } else if (pure_lossage && die_if_pure_storage_exceeded) {
+ fatal ("Pure storage exhausted");
+ }
+}
-#define SWEEP_FIXED_TYPE_BLOCK(typename, obj_type) \
-do { \
- struct typename##_block *SFTB_current; \
- struct typename##_block **SFTB_prev; \
- int SFTB_limit; \
- int num_free = 0, num_used = 0; \
- \
- for (SFTB_prev = ¤t_##typename##_block, \
- SFTB_current = current_##typename##_block, \
- SFTB_limit = current_##typename##_block_index; \
- SFTB_current; \
- ) \
- { \
- int SFTB_iii; \
- \
- for (SFTB_iii = 0; SFTB_iii < SFTB_limit; SFTB_iii++) \
- { \
- obj_type *SFTB_victim = &(SFTB_current->block[SFTB_iii]); \
- \
- if (FREE_STRUCT_P (SFTB_victim)) \
- { \
- num_free++; \
- } \
- else if (C_READONLY_RECORD_HEADER_P (&SFTB_victim->lheader)) \
- { \
- num_used++; \
- } \
- else if (!MARKED_RECORD_HEADER_P (&SFTB_victim->lheader)) \
- { \
- num_free++; \
- FREE_FIXED_TYPE (typename, obj_type, SFTB_victim); \
- } \
- else \
- { \
- num_used++; \
- UNMARK_##typename (SFTB_victim); \
- } \
- } \
- SFTB_prev = &(SFTB_current->prev); \
- SFTB_current = SFTB_current->prev; \
- SFTB_limit = countof (current_##typename##_block->block); \
- } \
- \
- gc_count_num_##typename##_in_use = num_used; \
- gc_count_num_##typename##_freelist = num_free; \
-} while (0)
+\f
+/**********************************************************************/
+/* staticpro */
+/**********************************************************************/
-#else /* !ERROR_CHECK_GC */
+struct gcpro *gcprolist;
-#define SWEEP_FIXED_TYPE_BLOCK(typename, obj_type) \
-do { \
- struct typename##_block *SFTB_current; \
- struct typename##_block **SFTB_prev; \
- int SFTB_limit; \
- int num_free = 0, num_used = 0; \
- \
- typename##_free_list = 0; \
- \
- for (SFTB_prev = ¤t_##typename##_block, \
- SFTB_current = current_##typename##_block, \
- SFTB_limit = current_##typename##_block_index; \
- SFTB_current; \
- ) \
- { \
- int SFTB_iii; \
- int SFTB_empty = 1; \
- obj_type *SFTB_old_free_list = typename##_free_list; \
- \
- for (SFTB_iii = 0; SFTB_iii < SFTB_limit; SFTB_iii++) \
- { \
- obj_type *SFTB_victim = &(SFTB_current->block[SFTB_iii]); \
- \
- if (FREE_STRUCT_P (SFTB_victim)) \
- { \
- num_free++; \
- PUT_FIXED_TYPE_ON_FREE_LIST (typename, obj_type, SFTB_victim); \
- } \
- else if (C_READONLY_RECORD_HEADER_P (&SFTB_victim->lheader)) \
- { \
- SFTB_empty = 0; \
- num_used++; \
- } \
- else if (!MARKED_RECORD_HEADER_P (&SFTB_victim->lheader)) \
- { \
- num_free++; \
- FREE_FIXED_TYPE (typename, obj_type, SFTB_victim); \
- } \
- else \
- { \
- SFTB_empty = 0; \
- num_used++; \
- UNMARK_##typename (SFTB_victim); \
- } \
- } \
- if (!SFTB_empty) \
- { \
- SFTB_prev = &(SFTB_current->prev); \
- SFTB_current = SFTB_current->prev; \
- } \
- else if (SFTB_current == current_##typename##_block \
- && !SFTB_current->prev) \
- { \
- /* No real point in freeing sole allocation block */ \
- break; \
- } \
- else \
- { \
- struct typename##_block *SFTB_victim_block = SFTB_current; \
- if (SFTB_victim_block == current_##typename##_block) \
- current_##typename##_block_index \
- = countof (current_##typename##_block->block); \
- SFTB_current = SFTB_current->prev; \
- { \
- *SFTB_prev = SFTB_current; \
- xfree (SFTB_victim_block); \
- /* Restore free list to what it was before victim was swept */ \
- typename##_free_list = SFTB_old_free_list; \
- num_free -= SFTB_limit; \
- } \
- } \
- SFTB_limit = countof (current_##typename##_block->block); \
- } \
- \
- gc_count_num_##typename##_in_use = num_used; \
- gc_count_num_##typename##_freelist = num_free; \
-} while (0)
+/* 415 used Mly 29-Jun-93 */
+/* 1327 used slb 28-Feb-98 */
+#ifdef HAVE_SHLIB
+#define NSTATICS 4000
+#else
+#define NSTATICS 2000
+#endif
+/* Not "static" because of linker lossage on some systems */
+Lisp_Object *staticvec[NSTATICS]
+ /* Force it into data space! */
+ = {0};
+static int staticidx;
-#endif /* !ERROR_CHECK_GC */
+/* Put an entry in staticvec, pointing at the variable whose address is given
+ */
+void
+staticpro (Lisp_Object *varaddress)
+{
+ if (staticidx >= countof (staticvec))
+ /* #### This is now a dubious abort() since this routine may be called */
+ /* by Lisp attempting to load a DLL. */
+ abort ();
+ staticvec[staticidx++] = varaddress;
+}
\f
-
+/* Mark reference to a Lisp_Object. If the object referred to has not been
+ seen yet, recursively mark all the references contained in it. */
static void
-sweep_conses (void)
+mark_object (Lisp_Object obj)
{
-#define UNMARK_cons(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
-#define ADDITIONAL_FREE_cons(ptr)
+ tail_recurse:
- SWEEP_FIXED_TYPE_BLOCK (cons, struct Lisp_Cons);
-}
+ if (EQ (obj, Qnull_pointer))
+ return;
+ if (!POINTER_TYPE_P (XGCTYPE (obj)))
+ return;
+ if (PURIFIED (XPNTR (obj)))
+ return;
+ switch (XGCTYPE (obj))
+ {
+#ifndef LRECORD_CONS
+ case Lisp_Type_Cons:
+ {
+ struct Lisp_Cons *ptr = XCONS (obj);
+ if (CONS_MARKED_P (ptr))
+ break;
+ MARK_CONS (ptr);
+ /* If the cdr is nil, tail-recurse on the car. */
+ if (NILP (ptr->cdr))
+ {
+ obj = ptr->car;
+ }
+ else
+ {
+ mark_object (ptr->car);
+ obj = ptr->cdr;
+ }
+ goto tail_recurse;
+ }
+#endif
-/* Explicitly free a cons cell. */
-void
-free_cons (struct Lisp_Cons *ptr)
-{
+ case Lisp_Type_Record:
+ /* case Lisp_Symbol_Value_Magic: */
+ {
+ struct lrecord_header *lheader = XRECORD_LHEADER (obj);
+ CONST struct lrecord_implementation *implementation
+ = LHEADER_IMPLEMENTATION (lheader);
+
+ if (! MARKED_RECORD_HEADER_P (lheader) &&
+ ! UNMARKABLE_RECORD_HEADER_P (lheader))
+ {
+ MARK_RECORD_HEADER (lheader);
#ifdef ERROR_CHECK_GC
- /* If the CAR is not an int, then it will be a pointer, which will
- always be four-byte aligned. If this cons cell has already been
- placed on the free list, however, its car will probably contain
- a chain pointer to the next cons on the list, which has cleverly
- had all its 0's and 1's inverted. This allows for a quick
- check to make sure we're not freeing something already freed. */
- if (POINTER_TYPE_P (XTYPE (ptr->car)))
- ASSERT_VALID_POINTER (XPNTR (ptr->car));
-#endif /* ERROR_CHECK_GC */
+ if (!implementation->basic_p)
+ assert (! ((struct lcrecord_header *) lheader)->free);
+#endif
+ if (implementation->marker != 0)
+ {
+ obj = ((implementation->marker) (obj, mark_object));
+ if (!NILP (obj)) goto tail_recurse;
+ }
+ }
+ }
+ break;
-#ifndef ALLOC_NO_POOLS
- FREE_FIXED_TYPE_WHEN_NOT_IN_GC (cons, struct Lisp_Cons, ptr);
-#endif /* ALLOC_NO_POOLS */
-}
+#ifndef LRECORD_STRING
+ case Lisp_Type_String:
+ {
+ struct Lisp_String *ptr = XSTRING (obj);
-/* explicitly free a list. You **must make sure** that you have
- created all the cons cells that make up this list and that there
- are no pointers to any of these cons cells anywhere else. If there
- are, you will lose. */
+ if (!XMARKBIT (ptr->plist))
+ {
+ if (CONSP (ptr->plist) &&
+ EXTENT_INFOP (XCAR (ptr->plist)))
+ flush_cached_extent_info (XCAR (ptr->plist));
+ XMARK (ptr->plist);
+ obj = ptr->plist;
+ goto tail_recurse;
+ }
+ }
+ break;
+#endif /* ! LRECORD_STRING */
-void
-free_list (Lisp_Object list)
-{
- Lisp_Object rest, next;
+#ifndef LRECORD_VECTOR
+ case Lisp_Type_Vector:
+ {
+ struct Lisp_Vector *ptr = XVECTOR (obj);
+ int len = vector_length (ptr);
+ int i;
- for (rest = list; !NILP (rest); rest = next)
- {
- next = XCDR (rest);
- free_cons (XCONS (rest));
+ if (len < 0)
+ break; /* Already marked */
+ ptr->size = -1 - len; /* Else mark it */
+ for (i = 0; i < len - 1; i++) /* and then mark its elements */
+ mark_object (ptr->contents[i]);
+ if (len > 0)
+ {
+ obj = ptr->contents[len - 1];
+ goto tail_recurse;
+ }
+ }
+ break;
+#endif /* !LRECORD_VECTOR */
+
+#ifndef LRECORD_SYMBOL
+ case Lisp_Type_Symbol:
+ {
+ struct Lisp_Symbol *sym = XSYMBOL (obj);
+
+ while (!XMARKBIT (sym->plist))
+ {
+ XMARK (sym->plist);
+ mark_object (sym->value);
+ mark_object (sym->function);
+ {
+ /*
+ * symbol->name is a struct Lisp_String *, not a
+ * Lisp_Object. Fix it up and pass to mark_object.
+ */
+ Lisp_Object symname;
+ XSETSTRING(symname, sym->name);
+ mark_object(symname);
+ }
+ if (!symbol_next (sym))
+ {
+ obj = sym->plist;
+ goto tail_recurse;
+ }
+ mark_object (sym->plist);
+ /* Mark the rest of the symbols in the hash-chain */
+ sym = symbol_next (sym);
+ }
+ }
+ break;
+#endif /* !LRECORD_SYMBOL */
+
+ default:
+ abort ();
}
}
-/* explicitly free an alist. You **must make sure** that you have
- created all the cons cells that make up this alist and that there
- are no pointers to any of these cons cells anywhere else. If there
- are, you will lose. */
+/* mark all of the conses in a list and mark the final cdr; but
+ DO NOT mark the cars.
+ Use only for internal lists! There should never be other pointers
+ to the cons cells, because if so, the cars will remain unmarked
+ even when they maybe should be marked. */
void
-free_alist (Lisp_Object alist)
+mark_conses_in_list (Lisp_Object obj)
{
- Lisp_Object rest, next;
+ Lisp_Object rest;
- for (rest = alist; !NILP (rest); rest = next)
+ for (rest = obj; CONSP (rest); rest = XCDR (rest))
{
- next = XCDR (rest);
- free_cons (XCONS (XCAR (rest)));
- free_cons (XCONS (rest));
+ if (CONS_MARKED_P (XCONS (rest)))
+ return;
+ MARK_CONS (XCONS (rest));
}
-}
-
-static void
-sweep_compiled_functions (void)
-{
-#define UNMARK_compiled_function(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
-#define ADDITIONAL_FREE_compiled_function(ptr)
- SWEEP_FIXED_TYPE_BLOCK (compiled_function, Lisp_Compiled_Function);
+ mark_object (rest);
}
+\f
+#ifdef PURESTAT
+/* Simpler than mark-object, because pure structure can't
+ have any circularities */
-#ifdef LISP_FLOAT_TYPE
+#if 0 /* unused */
+static int idiot_c_doesnt_have_closures;
static void
-sweep_floats (void)
+idiot_c (Lisp_Object obj)
{
-#define UNMARK_float(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
-#define ADDITIONAL_FREE_float(ptr)
-
- SWEEP_FIXED_TYPE_BLOCK (float, struct Lisp_Float);
+ idiot_c_doesnt_have_closures += pure_sizeof (obj, 1);
}
-#endif /* LISP_FLOAT_TYPE */
+#endif /* unused */
-static void
-sweep_symbols (void)
+static size_t
+pure_string_sizeof (Lisp_Object obj)
{
-#define UNMARK_symbol(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
-#define ADDITIONAL_FREE_symbol(ptr)
+ struct Lisp_String *ptr = XSTRING (obj);
- SWEEP_FIXED_TYPE_BLOCK (symbol, struct Lisp_Symbol);
+ if (string_data (ptr) != (Bufbyte *) ptr + sizeof (*ptr))
+ {
+ /* string-data not allocated contiguously.
+ Probably (better be!!) a pointer constant "C" data. */
+ return sizeof (*ptr);
+ }
+ else
+ {
+ size_t size = sizeof (*ptr) + string_length (ptr) + 1;
+ size = ALIGN_SIZE (size, sizeof (Lisp_Object));
+ return size;
+ }
}
-static void
-sweep_extents (void)
-{
-#define UNMARK_extent(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
-#define ADDITIONAL_FREE_extent(ptr)
-
- SWEEP_FIXED_TYPE_BLOCK (extent, struct extent);
-}
-
-static void
-sweep_events (void)
+/* recurse arg isn't actually used */
+static size_t
+pure_sizeof (Lisp_Object obj /*, int recurse */)
{
-#define UNMARK_event(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
-#define ADDITIONAL_FREE_event(ptr)
+ size_t total = 0;
- SWEEP_FIXED_TYPE_BLOCK (event, struct Lisp_Event);
-}
+ /*tail_recurse: */
+ if (!POINTER_TYPE_P (XTYPE (obj))
+ || !PURIFIED (XPNTR (obj)))
+ return total;
-static void
-sweep_markers (void)
-{
-#define UNMARK_marker(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
-#define ADDITIONAL_FREE_marker(ptr) \
- do { Lisp_Object tem; \
- XSETMARKER (tem, ptr); \
- unchain_marker (tem); \
- } while (0)
+ /* symbol's sizes are accounted for separately */
+ if (SYMBOLP (obj))
+ return total;
- SWEEP_FIXED_TYPE_BLOCK (marker, struct Lisp_Marker);
-}
+ switch (XTYPE (obj))
+ {
-/* Explicitly free a marker. */
-void
-free_marker (struct Lisp_Marker *ptr)
-{
-#ifdef ERROR_CHECK_GC
- /* Perhaps this will catch freeing an already-freed marker. */
- Lisp_Object temmy;
- XSETMARKER (temmy, ptr);
- assert (MARKERP (temmy));
-#endif /* ERROR_CHECK_GC */
+#ifndef LRECORD_STRING
+ case Lisp_Type_String:
+ total += pure_string_sizeof (obj);
+ break;
+#endif /* ! LRECORD_STRING */
-#ifndef ALLOC_NO_POOLS
- FREE_FIXED_TYPE_WHEN_NOT_IN_GC (marker, struct Lisp_Marker, ptr);
-#endif /* ALLOC_NO_POOLS */
-}
-\f
+#ifndef LRECORD_VECTOR
+ case Lisp_Type_Vector:
+ {
+ struct Lisp_Vector *ptr = XVECTOR (obj);
+ int len = vector_length (ptr);
+
+ total += (sizeof (struct Lisp_Vector)
+ + (len - 1) * sizeof (Lisp_Object));
+#if 0 /* unused */
+ if (!recurse)
+ break;
+ {
+ int i;
+ for (i = 0; i < len - 1; i++)
+ total += pure_sizeof (ptr->contents[i], 1);
+ }
+ if (len > 0)
+ {
+ obj = ptr->contents[len - 1];
+ goto tail_recurse;
+ }
+#endif /* unused */
+ }
+ break;
+#endif /* !LRECORD_VECTOR */
-#if defined (MULE) && defined (VERIFY_STRING_CHARS_INTEGRITY)
+ case Lisp_Type_Record:
+ {
+ struct lrecord_header *lheader = XRECORD_LHEADER (obj);
+ CONST struct lrecord_implementation *implementation
+ = LHEADER_IMPLEMENTATION (lheader);
-static void
-verify_string_chars_integrity (void)
-{
- struct string_chars_block *sb;
+#ifdef LRECORD_STRING
+ if (STRINGP (obj))
+ total += pure_string_sizeof (obj);
+ else
+#endif
+ if (implementation->size_in_bytes_method)
+ total += ((implementation->size_in_bytes_method) (lheader));
+ else
+ total += implementation->static_size;
- /* Scan each existing string block sequentially, string by string. */
- for (sb = first_string_chars_block; sb; sb = sb->next)
- {
- int pos = 0;
- /* POS is the index of the next string in the block. */
- while (pos < sb->pos)
- {
- struct string_chars *s_chars =
- (struct string_chars *) &(sb->string_chars[pos]);
- struct Lisp_String *string;
- int size;
- int fullsize;
+#if 0 /* unused */
+ if (!recurse)
+ break;
- /* If the string_chars struct is marked as free (i.e. the STRING
- pointer is 0xFFFFFFFF) then this is an unused chunk of string
- storage. (See below.) */
+ if (implementation->marker != 0)
+ {
+ int old = idiot_c_doesnt_have_closures;
- if (FREE_STRUCT_P (s_chars))
- {
- fullsize = ((struct unused_string_chars *) s_chars)->fullsize;
- pos += fullsize;
- continue;
- }
+ idiot_c_doesnt_have_closures = 0;
+ obj = ((implementation->marker) (obj, idiot_c));
+ total += idiot_c_doesnt_have_closures;
+ idiot_c_doesnt_have_closures = old;
- string = s_chars->string;
- /* Must be 32-bit aligned. */
- assert ((((int) string) & 3) == 0);
+ if (!NILP (obj)) goto tail_recurse;
+ }
+#endif /* unused */
+ }
+ break;
- size = string_length (string);
- fullsize = STRING_FULLSIZE (size);
+#ifndef LRECORD_CONS
+ case Lisp_Type_Cons:
+ {
+ struct Lisp_Cons *ptr = XCONS (obj);
+ total += sizeof (*ptr);
+#if 0 /* unused */
+ if (!recurse)
+ break;
+ /* If the cdr is nil, tail-recurse on the car. */
+ if (NILP (ptr->cdr))
+ {
+ obj = ptr->car;
+ }
+ else
+ {
+ total += pure_sizeof (ptr->car, 1);
+ obj = ptr->cdr;
+ }
+ goto tail_recurse;
+#endif /* unused */
+ }
+ break;
+#endif
- assert (!BIG_STRING_FULLSIZE_P (fullsize));
- assert (string_data (string) == s_chars->chars);
- pos += fullsize;
- }
- assert (pos == sb->pos);
+ /* Others can't be purified */
+ default:
+ abort ();
}
+ return total;
}
+#endif /* PURESTAT */
-#endif /* MULE && ERROR_CHECK_GC */
-
-/* Compactify string chars, relocating the reference to each --
- free any empty string_chars_block we see. */
-static void
-compact_string_chars (void)
-{
- struct string_chars_block *to_sb = first_string_chars_block;
- int to_pos = 0;
- struct string_chars_block *from_sb;
-
- /* Scan each existing string block sequentially, string by string. */
- for (from_sb = first_string_chars_block; from_sb; from_sb = from_sb->next)
- {
- int from_pos = 0;
- /* FROM_POS is the index of the next string in the block. */
- while (from_pos < from_sb->pos)
- {
- struct string_chars *from_s_chars =
- (struct string_chars *) &(from_sb->string_chars[from_pos]);
- struct string_chars *to_s_chars;
- struct Lisp_String *string;
- int size;
- int fullsize;
-
- /* If the string_chars struct is marked as free (i.e. the STRING
- pointer is 0xFFFFFFFF) then this is an unused chunk of string
- storage. This happens under Mule when a string's size changes
- in such a way that its fullsize changes. (Strings can change
- size because a different-length character can be substituted
- for another character.) In this case, after the bogus string
- pointer is the "fullsize" of this entry, i.e. how many bytes
- to skip. */
-
- if (FREE_STRUCT_P (from_s_chars))
- {
- fullsize = ((struct unused_string_chars *) from_s_chars)->fullsize;
- from_pos += fullsize;
- continue;
- }
-
- string = from_s_chars->string;
- assert (!(FREE_STRUCT_P (string)));
-
- size = string_length (string);
- fullsize = STRING_FULLSIZE (size);
- if (BIG_STRING_FULLSIZE_P (fullsize))
- abort ();
- /* Just skip it if it isn't marked. */
- if (! MARKED_RECORD_HEADER_P (&(string->lheader)))
- {
- from_pos += fullsize;
- continue;
- }
+\f
+/* Find all structures not marked, and free them. */
- /* If it won't fit in what's left of TO_SB, close TO_SB out
- and go on to the next string_chars_block. We know that TO_SB
- cannot advance past FROM_SB here since FROM_SB is large enough
- to currently contain this string. */
- if ((to_pos + fullsize) > countof (to_sb->string_chars))
- {
- to_sb->pos = to_pos;
- to_sb = to_sb->next;
- to_pos = 0;
- }
+#ifndef LRECORD_VECTOR
+static int gc_count_num_vector_used, gc_count_vector_total_size;
+static int gc_count_vector_storage;
+#endif
+static int gc_count_num_bit_vector_used, gc_count_bit_vector_total_size;
+static int gc_count_bit_vector_storage;
+static int gc_count_num_short_string_in_use;
+static int gc_count_string_total_size;
+static int gc_count_short_string_total_size;
- /* Compute new address of this string
- and update TO_POS for the space being used. */
- to_s_chars = (struct string_chars *) &(to_sb->string_chars[to_pos]);
+/* static int gc_count_total_records_used, gc_count_records_total_size; */
- /* Copy the string_chars to the new place. */
- if (from_s_chars != to_s_chars)
- memmove (to_s_chars, from_s_chars, fullsize);
+\f
+/* This will be used more extensively In The Future */
+static int last_lrecord_type_index_assigned;
- /* Relocate FROM_S_CHARS's reference */
- set_string_data (string, &(to_s_chars->chars[0]));
+CONST struct lrecord_implementation *lrecord_implementations_table[128];
+#define max_lrecord_type (countof (lrecord_implementations_table) - 1)
- from_pos += fullsize;
- to_pos += fullsize;
- }
+int
+lrecord_type_index (CONST struct lrecord_implementation *implementation)
+{
+ int type_index = *(implementation->lrecord_type_index);
+ /* Have to do this circuitous validation test because of problems
+ dumping out initialized variables (ie can't set xxx_type_index to -1
+ because that would make xxx_type_index read-only in a dumped emacs. */
+ if (type_index < 0 || type_index > max_lrecord_type
+ || lrecord_implementations_table[type_index] != implementation)
+ {
+ if (last_lrecord_type_index_assigned == max_lrecord_type)
+ abort ();
+ type_index = ++last_lrecord_type_index_assigned;
+ lrecord_implementations_table[type_index] = implementation;
+ *(implementation->lrecord_type_index) = type_index;
}
+ return type_index;
+}
- /* Set current to the last string chars block still used and
- free any that follow. */
- {
- struct string_chars_block *victim;
-
- for (victim = to_sb->next; victim; )
- {
- struct string_chars_block *next = victim->next;
- xfree (victim);
- victim = next;
- }
+/* stats on lcrecords in use - kinda kludgy */
- current_string_chars_block = to_sb;
- current_string_chars_block->pos = to_pos;
- current_string_chars_block->next = 0;
- }
-}
+static struct
+{
+ int instances_in_use;
+ int bytes_in_use;
+ int instances_freed;
+ int bytes_freed;
+ int instances_on_free_list;
+} lcrecord_stats [countof (lrecord_implementations_table)];
-#if 1 /* Hack to debug missing purecopy's */
-static int debug_string_purity;
static void
-debug_string_purity_print (struct Lisp_String *p)
+reset_lcrecord_stats (void)
{
- Charcount i;
- Charcount s = string_char_length (p);
- putc ('\"', stderr);
- for (i = 0; i < s; i++)
- {
- Emchar ch = string_char (p, i);
- if (ch < 32 || ch >= 126)
- stderr_out ("\\%03o", ch);
- else if (ch == '\\' || ch == '\"')
- stderr_out ("\\%c", ch);
- else
- stderr_out ("%c", ch);
- }
- stderr_out ("\"\n");
+ int i;
+ for (i = 0; i < countof (lcrecord_stats); i++)
+ {
+ lcrecord_stats[i].instances_in_use = 0;
+ lcrecord_stats[i].bytes_in_use = 0;
+ lcrecord_stats[i].instances_freed = 0;
+ lcrecord_stats[i].bytes_freed = 0;
+ lcrecord_stats[i].instances_on_free_list = 0;
+ }
}
-#endif /* 1 */
-
static void
-sweep_strings (void)
+tick_lcrecord_stats (CONST struct lrecord_header *h, int free_p)
{
- int num_small_used = 0, num_small_bytes = 0, num_bytes = 0;
- int debug = debug_string_purity;
+ CONST struct lrecord_implementation *implementation =
+ LHEADER_IMPLEMENTATION (h);
+ int type_index = lrecord_type_index (implementation);
-#define UNMARK_string(ptr) \
- do { struct Lisp_String *p = (ptr); \
- int size = string_length (p); \
- UNMARK_RECORD_HEADER (&(p->lheader)); \
- num_bytes += size; \
- if (!BIG_STRING_SIZE_P (size)) \
- { num_small_bytes += size; \
- num_small_used++; \
- } \
- if (debug) debug_string_purity_print (p); \
- } while (0)
-#define ADDITIONAL_FREE_string(p) \
- do { int size = string_length (p); \
- if (BIG_STRING_SIZE_P (size)) \
- xfree_1 (CHARS_TO_STRING_CHAR (string_data (p))); \
- } while (0)
+ if (((struct lcrecord_header *) h)->free)
+ {
+ assert (!free_p);
+ lcrecord_stats[type_index].instances_on_free_list++;
+ }
+ else
+ {
+ size_t sz = (implementation->size_in_bytes_method
+ ? ((implementation->size_in_bytes_method) (h))
+ : implementation->static_size);
- SWEEP_FIXED_TYPE_BLOCK (string, struct Lisp_String);
+ if (free_p)
+ {
+ lcrecord_stats[type_index].instances_freed++;
+ lcrecord_stats[type_index].bytes_freed += sz;
+ }
+ else
+ {
+ lcrecord_stats[type_index].instances_in_use++;
+ lcrecord_stats[type_index].bytes_in_use += sz;
+ }
+ }
+}
- gc_count_num_short_string_in_use = num_small_used;
- gc_count_string_total_size = num_bytes;
- gc_count_short_string_total_size = num_small_bytes;
+\f
+/* Free all unmarked records */
+static void
+sweep_lcrecords_1 (struct lcrecord_header **prev, int *used)
+{
+ struct lcrecord_header *header;
+ int num_used = 0;
+ /* int total_size = 0; */
+ reset_lcrecord_stats ();
+
+ /* First go through and call all the finalize methods.
+ Then go through and free the objects. There used to
+ be only one loop here, with the call to the finalizer
+ occurring directly before the xfree() below. That
+ is marginally faster but much less safe -- if the
+ finalize method for an object needs to reference any
+ other objects contained within it (and many do),
+ we could easily be screwed by having already freed that
+ other object. */
+
+ for (header = *prev; header; header = header->next)
+ {
+ struct lrecord_header *h = &(header->lheader);
+ if (!MARKED_RECORD_HEADER_P (h) && ! (header->free))
+ {
+ if (LHEADER_IMPLEMENTATION (h)->finalizer)
+ ((LHEADER_IMPLEMENTATION (h)->finalizer) (h, 0));
+ }
+ }
+
+ for (header = *prev; header; )
+ {
+ struct lrecord_header *h = &(header->lheader);
+ if (MARKED_RECORD_HEADER_P (h))
+ {
+ UNMARK_RECORD_HEADER (h);
+ num_used++;
+ /* total_size += ((n->implementation->size_in_bytes) (h));*/
+ prev = &(header->next);
+ header = *prev;
+ tick_lcrecord_stats (h, 0);
+ }
+ else
+ {
+ struct lcrecord_header *next = header->next;
+ *prev = next;
+ tick_lcrecord_stats (h, 1);
+ /* used to call finalizer right here. */
+ xfree (header);
+ header = next;
+ }
+ }
+ *used = num_used;
+ /* *total = total_size; */
}
+#ifndef LRECORD_VECTOR
-/* I hate duplicating all this crap! */
-int
-marked_p (Lisp_Object obj)
+static void
+sweep_vectors_1 (Lisp_Object *prev,
+ int *used, int *total, int *storage)
{
-#ifdef ERROR_CHECK_GC
- assert (! (EQ (obj, Qnull_pointer)));
-#endif
- /* Checks we used to perform. */
- /* if (EQ (obj, Qnull_pointer)) return 1; */
- /* if (!POINTER_TYPE_P (XGCTYPE (obj))) return 1; */
- /* if (PURIFIED (XPNTR (obj))) return 1; */
+ Lisp_Object vector;
+ int num_used = 0;
+ int total_size = 0;
+ int total_storage = 0;
- if (XTYPE (obj) == Lisp_Type_Record)
+ for (vector = *prev; VECTORP (vector); )
{
- struct lrecord_header *lheader = XRECORD_LHEADER (obj);
-#if defined (ERROR_CHECK_GC)
- assert (lheader->type <= last_lrecord_type_index_assigned);
-#endif
- return C_READONLY_RECORD_HEADER_P (lheader) || MARKED_RECORD_HEADER_P (lheader);
+ struct Lisp_Vector *v = XVECTOR (vector);
+ int len = v->size;
+ if (len < 0) /* marked */
+ {
+ len = - (len + 1);
+ v->size = len;
+ total_size += len;
+ total_storage += (MALLOC_OVERHEAD
+ + sizeof (struct Lisp_Vector)
+ + (len - 1 + 1) * sizeof (Lisp_Object));
+ num_used++;
+ prev = &(vector_next (v));
+ vector = *prev;
+ }
+ else
+ {
+ Lisp_Object next = vector_next (v);
+ *prev = next;
+ xfree (v);
+ vector = next;
+ }
}
- return 1;
+ *used = num_used;
+ *total = total_size;
+ *storage = total_storage;
}
+#endif /* ! LRECORD_VECTOR */
+
static void
-gc_sweep (void)
+sweep_bit_vectors_1 (Lisp_Object *prev,
+ int *used, int *total, int *storage)
{
- /* Free all unmarked records. Do this at the very beginning,
- before anything else, so that the finalize methods can safely
- examine items in the objects. sweep_lcrecords_1() makes
- sure to call all the finalize methods *before* freeing anything,
- to complete the safety. */
- {
- int ignored;
- sweep_lcrecords_1 (&all_lcrecords, &ignored);
- }
-
- compact_string_chars ();
+ Lisp_Object bit_vector;
+ int num_used = 0;
+ int total_size = 0;
+ int total_storage = 0;
- /* Finalize methods below (called through the ADDITIONAL_FREE_foo
- macros) must be *extremely* careful to make sure they're not
- referencing freed objects. The only two existing finalize
- methods (for strings and markers) pass muster -- the string
- finalizer doesn't look at anything but its own specially-
- created block, and the marker finalizer only looks at live
- buffers (which will never be freed) and at the markers before
- and after it in the chain (which, by induction, will never be
- freed because if so, they would have already removed themselves
- from the chain). */
+ /* BIT_VECTORP fails because the objects are marked, which changes
+ their implementation */
+ for (bit_vector = *prev; !EQ (bit_vector, Qzero); )
+ {
+ struct Lisp_Bit_Vector *v = XBIT_VECTOR (bit_vector);
+ int len = v->size;
+ if (MARKED_RECORD_P (bit_vector))
+ {
+ UNMARK_RECORD_HEADER (&(v->lheader));
+ total_size += len;
+ total_storage += (MALLOC_OVERHEAD
+ + sizeof (struct Lisp_Bit_Vector)
+ + (BIT_VECTOR_LONG_STORAGE (len) - 1)
+ * sizeof (long));
+ num_used++;
+ prev = &(bit_vector_next (v));
+ bit_vector = *prev;
+ }
+ else
+ {
+ Lisp_Object next = bit_vector_next (v);
+ *prev = next;
+ xfree (v);
+ bit_vector = next;
+ }
+ }
+ *used = num_used;
+ *total = total_size;
+ *storage = total_storage;
+}
- /* Put all unmarked strings on free list, free'ing the string chars
- of large unmarked strings */
- sweep_strings ();
+/* And the Lord said: Thou shalt use the `c-backslash-region' command
+ to make macros prettier. */
- /* Put all unmarked conses on free list */
- sweep_conses ();
+#ifdef ERROR_CHECK_GC
- /* Free all unmarked bit vectors */
- sweep_bit_vectors_1 (&all_bit_vectors,
- &gc_count_num_bit_vector_used,
- &gc_count_bit_vector_total_size,
- &gc_count_bit_vector_storage);
+#define SWEEP_FIXED_TYPE_BLOCK(typename, obj_type) \
+do { \
+ struct typename##_block *_frob_current; \
+ struct typename##_block **_frob_prev; \
+ int _frob_limit; \
+ int num_free = 0, num_used = 0; \
+ \
+ for (_frob_prev = ¤t_##typename##_block, \
+ _frob_current = current_##typename##_block, \
+ _frob_limit = current_##typename##_block_index; \
+ _frob_current; \
+ ) \
+ { \
+ int _frob_iii; \
+ \
+ for (_frob_iii = 0; _frob_iii < _frob_limit; _frob_iii++) \
+ { \
+ obj_type *_frob_victim = &(_frob_current->block[_frob_iii]); \
+ \
+ if (FREE_STRUCT_P (_frob_victim)) \
+ { \
+ num_free++; \
+ } \
+ else if (!MARKED_##typename##_P (_frob_victim)) \
+ { \
+ num_free++; \
+ FREE_FIXED_TYPE (typename, obj_type, _frob_victim); \
+ } \
+ else \
+ { \
+ num_used++; \
+ UNMARK_##typename (_frob_victim); \
+ } \
+ } \
+ _frob_prev = &(_frob_current->prev); \
+ _frob_current = _frob_current->prev; \
+ _frob_limit = countof (current_##typename##_block->block); \
+ } \
+ \
+ gc_count_num_##typename##_in_use = num_used; \
+ gc_count_num_##typename##_freelist = num_free; \
+} while (0)
- /* Free all unmarked compiled-function objects */
- sweep_compiled_functions ();
+#else /* !ERROR_CHECK_GC */
-#ifdef LISP_FLOAT_TYPE
- /* Put all unmarked floats on free list */
- sweep_floats ();
-#endif
+#define SWEEP_FIXED_TYPE_BLOCK(typename, obj_type) \
+do { \
+ struct typename##_block *_frob_current; \
+ struct typename##_block **_frob_prev; \
+ int _frob_limit; \
+ int num_free = 0, num_used = 0; \
+ \
+ typename##_free_list = 0; \
+ \
+ for (_frob_prev = ¤t_##typename##_block, \
+ _frob_current = current_##typename##_block, \
+ _frob_limit = current_##typename##_block_index; \
+ _frob_current; \
+ ) \
+ { \
+ int _frob_iii; \
+ int _frob_empty = 1; \
+ obj_type *_frob_old_free_list = typename##_free_list; \
+ \
+ for (_frob_iii = 0; _frob_iii < _frob_limit; _frob_iii++) \
+ { \
+ obj_type *_frob_victim = &(_frob_current->block[_frob_iii]); \
+ \
+ if (FREE_STRUCT_P (_frob_victim)) \
+ { \
+ num_free++; \
+ PUT_FIXED_TYPE_ON_FREE_LIST (typename, obj_type, _frob_victim); \
+ } \
+ else if (!MARKED_##typename##_P (_frob_victim)) \
+ { \
+ num_free++; \
+ FREE_FIXED_TYPE (typename, obj_type, _frob_victim); \
+ } \
+ else \
+ { \
+ _frob_empty = 0; \
+ num_used++; \
+ UNMARK_##typename (_frob_victim); \
+ } \
+ } \
+ if (!_frob_empty) \
+ { \
+ _frob_prev = &(_frob_current->prev); \
+ _frob_current = _frob_current->prev; \
+ } \
+ else if (_frob_current == current_##typename##_block \
+ && !_frob_current->prev) \
+ { \
+ /* No real point in freeing sole allocation block */ \
+ break; \
+ } \
+ else \
+ { \
+ struct typename##_block *_frob_victim_block = _frob_current; \
+ if (_frob_victim_block == current_##typename##_block) \
+ current_##typename##_block_index \
+ = countof (current_##typename##_block->block); \
+ _frob_current = _frob_current->prev; \
+ { \
+ *_frob_prev = _frob_current; \
+ xfree (_frob_victim_block); \
+ /* Restore free list to what it was before victim was swept */ \
+ typename##_free_list = _frob_old_free_list; \
+ num_free -= _frob_limit; \
+ } \
+ } \
+ _frob_limit = countof (current_##typename##_block->block); \
+ } \
+ \
+ gc_count_num_##typename##_in_use = num_used; \
+ gc_count_num_##typename##_freelist = num_free; \
+} while (0)
- /* Put all unmarked symbols on free list */
- sweep_symbols ();
+#endif /* !ERROR_CHECK_GC */
- /* Put all unmarked extents on free list */
- sweep_extents ();
+\f
- /* Put all unmarked markers on free list.
- Dechain each one first from the buffer into which it points. */
- sweep_markers ();
- sweep_events ();
+static void
+sweep_conses (void)
+{
+#ifndef LRECORD_CONS
+# define MARKED_cons_P(ptr) XMARKBIT ((ptr)->car)
+# define UNMARK_cons(ptr) do { XUNMARK ((ptr)->car); } while (0)
+#else /* LRECORD_CONS */
+# define MARKED_cons_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
+# define UNMARK_cons(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#endif /* LRECORD_CONS */
+#define ADDITIONAL_FREE_cons(ptr)
-#ifdef PDUMP
- /* Unmark all dumped objects */
- {
- int i;
- char *p = pdump_rt_list;
- if(p)
- for(;;)
- {
- pdump_reloc_table *rt = (pdump_reloc_table *)p;
- p += sizeof (pdump_reloc_table);
- if (rt->desc) {
- for (i=0; i<rt->count; i++)
- {
- UNMARK_RECORD_HEADER ((struct lrecord_header *)(*(EMACS_INT *)p));
- p += sizeof (EMACS_INT);
- }
- } else
- break;
- }
- }
-#endif
+ SWEEP_FIXED_TYPE_BLOCK (cons, struct Lisp_Cons);
}
-\f
-/* Clearing for disksave. */
+/* Explicitly free a cons cell. */
void
-disksave_object_finalization (void)
+free_cons (struct Lisp_Cons *ptr)
{
- /* It's important that certain information from the environment not get
- dumped with the executable (pathnames, environment variables, etc.).
- To make it easier to tell when this has happened with strings(1) we
- clear some known-to-be-garbage blocks of memory, so that leftover
- results of old evaluation don't look like potential problems.
- But first we set some notable variables to nil and do one more GC,
- to turn those strings into garbage.
- */
-
- /* Yeah, this list is pretty ad-hoc... */
- Vprocess_environment = Qnil;
- Vexec_directory = Qnil;
- Vdata_directory = Qnil;
- Vsite_directory = Qnil;
- Vdoc_directory = Qnil;
- Vconfigure_info_directory = Qnil;
- Vexec_path = Qnil;
- Vload_path = Qnil;
- /* Vdump_load_path = Qnil; */
- /* Release hash tables for locate_file */
- Flocate_file_clear_hashing (Qt);
- uncache_home_directory();
+#ifdef ERROR_CHECK_GC
+ /* If the CAR is not an int, then it will be a pointer, which will
+ always be four-byte aligned. If this cons cell has already been
+ placed on the free list, however, its car will probably contain
+ a chain pointer to the next cons on the list, which has cleverly
+ had all its 0's and 1's inverted. This allows for a quick
+ check to make sure we're not freeing something already freed. */
+ if (POINTER_TYPE_P (XTYPE (ptr->car)))
+ ASSERT_VALID_POINTER (XPNTR (ptr->car));
+#endif /* ERROR_CHECK_GC */
-#if defined(LOADHIST) && !(defined(LOADHIST_DUMPED) || \
- defined(LOADHIST_BUILTIN))
- Vload_history = Qnil;
-#endif
- Vshell_file_name = Qnil;
+#ifndef ALLOC_NO_POOLS
+ FREE_FIXED_TYPE_WHEN_NOT_IN_GC (cons, struct Lisp_Cons, ptr);
+#endif /* ALLOC_NO_POOLS */
+}
- garbage_collect_1 ();
+/* explicitly free a list. You **must make sure** that you have
+ created all the cons cells that make up this list and that there
+ are no pointers to any of these cons cells anywhere else. If there
+ are, you will lose. */
- /* Run the disksave finalization methods of all live objects. */
- disksave_object_finalization_1 ();
+void
+free_list (Lisp_Object list)
+{
+ Lisp_Object rest, next;
- /* Zero out the uninitialized (really, unused) part of the containers
- for the live strings. */
- {
- struct string_chars_block *scb;
- for (scb = first_string_chars_block; scb; scb = scb->next)
- {
- int count = sizeof (scb->string_chars) - scb->pos;
+ for (rest = list; !NILP (rest); rest = next)
+ {
+ next = XCDR (rest);
+ free_cons (XCONS (rest));
+ }
+}
- assert (count >= 0 && count < STRING_CHARS_BLOCK_SIZE);
- if (count != 0) {
- /* from the block's fill ptr to the end */
- memset ((scb->string_chars + scb->pos), 0, count);
- }
- }
- }
+/* explicitly free an alist. You **must make sure** that you have
+ created all the cons cells that make up this alist and that there
+ are no pointers to any of these cons cells anywhere else. If there
+ are, you will lose. */
- /* There, that ought to be enough... */
+void
+free_alist (Lisp_Object alist)
+{
+ Lisp_Object rest, next;
+ for (rest = alist; !NILP (rest); rest = next)
+ {
+ next = XCDR (rest);
+ free_cons (XCONS (XCAR (rest)));
+ free_cons (XCONS (rest));
+ }
}
-\f
-Lisp_Object
-restore_gc_inhibit (Lisp_Object val)
+static void
+sweep_compiled_functions (void)
{
- gc_currently_forbidden = XINT (val);
- return val;
+#define MARKED_compiled_function_P(ptr) \
+ MARKED_RECORD_HEADER_P (&((ptr)->lheader))
+#define UNMARK_compiled_function(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_compiled_function(ptr)
+
+ SWEEP_FIXED_TYPE_BLOCK (compiled_function, struct Lisp_Compiled_Function);
}
-/* Maybe we want to use this when doing a "panic" gc after memory_full()? */
-static int gc_hooks_inhibited;
-\f
-void
-garbage_collect_1 (void)
+#ifdef LISP_FLOAT_TYPE
+static void
+sweep_floats (void)
{
-#if MAX_SAVE_STACK > 0
- char stack_top_variable;
- extern char *stack_bottom;
-#endif
- struct frame *f;
- int speccount;
- int cursor_changed;
- Lisp_Object pre_gc_cursor;
- struct gcpro gcpro1;
+#define MARKED_float_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
+#define UNMARK_float(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_float(ptr)
- if (gc_in_progress
- || gc_currently_forbidden
- || in_display
- || preparing_for_armageddon)
- return;
+ SWEEP_FIXED_TYPE_BLOCK (float, struct Lisp_Float);
+}
+#endif /* LISP_FLOAT_TYPE */
- /* We used to call selected_frame() here.
+static void
+sweep_symbols (void)
+{
+#ifndef LRECORD_SYMBOL
+# define MARKED_symbol_P(ptr) XMARKBIT ((ptr)->plist)
+# define UNMARK_symbol(ptr) do { XUNMARK ((ptr)->plist); } while (0)
+#else
+# define MARKED_symbol_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
+# define UNMARK_symbol(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#endif /* !LRECORD_SYMBOL */
+#define ADDITIONAL_FREE_symbol(ptr)
- The following functions cannot be called inside GC
- so we move to after the above tests. */
- {
- Lisp_Object frame;
- Lisp_Object device = Fselected_device (Qnil);
- if (NILP (device)) /* Could happen during startup, eg. if always_gc */
- return;
- frame = DEVICE_SELECTED_FRAME (XDEVICE (device));
- if (NILP (frame))
- signal_simple_error ("No frames exist on device", device);
- f = XFRAME (frame);
- }
+ SWEEP_FIXED_TYPE_BLOCK (symbol, struct Lisp_Symbol);
+}
- pre_gc_cursor = Qnil;
- cursor_changed = 0;
+static void
+sweep_extents (void)
+{
+#define MARKED_extent_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
+#define UNMARK_extent(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_extent(ptr)
- GCPRO1 (pre_gc_cursor);
+ SWEEP_FIXED_TYPE_BLOCK (extent, struct extent);
+}
- /* Very important to prevent GC during any of the following
- stuff that might run Lisp code; otherwise, we'll likely
- have infinite GC recursion. */
- speccount = specpdl_depth ();
- record_unwind_protect (restore_gc_inhibit,
- make_int (gc_currently_forbidden));
- gc_currently_forbidden = 1;
+static void
+sweep_events (void)
+{
+#define MARKED_event_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
+#define UNMARK_event(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_event(ptr)
- if (!gc_hooks_inhibited)
- run_hook_trapping_errors ("Error in pre-gc-hook", Qpre_gc_hook);
+ SWEEP_FIXED_TYPE_BLOCK (event, struct Lisp_Event);
+}
- /* Now show the GC cursor/message. */
- if (!noninteractive)
- {
- if (FRAME_WIN_P (f))
- {
- Lisp_Object frame = make_frame (f);
- Lisp_Object cursor = glyph_image_instance (Vgc_pointer_glyph,
- FRAME_SELECTED_WINDOW (f),
- ERROR_ME_NOT, 1);
- pre_gc_cursor = f->pointer;
- if (POINTER_IMAGE_INSTANCEP (cursor)
- /* don't change if we don't know how to change back. */
- && POINTER_IMAGE_INSTANCEP (pre_gc_cursor))
- {
- cursor_changed = 1;
- Fset_frame_pointer (frame, cursor);
- }
- }
+static void
+sweep_markers (void)
+{
+#define MARKED_marker_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
+#define UNMARK_marker(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_marker(ptr) \
+ do { Lisp_Object tem; \
+ XSETMARKER (tem, ptr); \
+ unchain_marker (tem); \
+ } while (0)
- /* Don't print messages to the stream device. */
- if (!cursor_changed && !FRAME_STREAM_P (f))
- {
- char *msg = (STRINGP (Vgc_message)
- ? GETTEXT ((char *) XSTRING_DATA (Vgc_message))
- : 0);
- Lisp_Object args[2], whole_msg;
- args[0] = build_string (msg ? msg :
- GETTEXT ((CONST char *) gc_default_message));
- args[1] = build_string ("...");
- whole_msg = Fconcat (2, args);
- echo_area_message (f, (Bufbyte *) 0, whole_msg, 0, -1,
- Qgarbage_collecting);
- }
- }
+ SWEEP_FIXED_TYPE_BLOCK (marker, struct Lisp_Marker);
+}
- /***** Now we actually start the garbage collection. */
+/* Explicitly free a marker. */
+void
+free_marker (struct Lisp_Marker *ptr)
+{
+#ifdef ERROR_CHECK_GC
+ /* Perhaps this will catch freeing an already-freed marker. */
+ Lisp_Object temmy;
+ XSETMARKER (temmy, ptr);
+ assert (GC_MARKERP (temmy));
+#endif /* ERROR_CHECK_GC */
- gc_in_progress = 1;
+#ifndef ALLOC_NO_POOLS
+ FREE_FIXED_TYPE_WHEN_NOT_IN_GC (marker, struct Lisp_Marker, ptr);
+#endif /* ALLOC_NO_POOLS */
+}
+\f
- gc_generation_number[0]++;
+#if defined (MULE) && defined (VERIFY_STRING_CHARS_INTEGRITY)
-#if MAX_SAVE_STACK > 0
+static void
+verify_string_chars_integrity (void)
+{
+ struct string_chars_block *sb;
- /* Save a copy of the contents of the stack, for debugging. */
- if (!purify_flag)
+ /* Scan each existing string block sequentially, string by string. */
+ for (sb = first_string_chars_block; sb; sb = sb->next)
{
- /* Static buffer in which we save a copy of the C stack at each GC. */
- static char *stack_copy;
- static size_t stack_copy_size;
+ int pos = 0;
+ /* POS is the index of the next string in the block. */
+ while (pos < sb->pos)
+ {
+ struct string_chars *s_chars =
+ (struct string_chars *) &(sb->string_chars[pos]);
+ struct Lisp_String *string;
+ int size;
+ int fullsize;
- ptrdiff_t stack_diff = &stack_top_variable - stack_bottom;
- size_t stack_size = (stack_diff > 0 ? stack_diff : -stack_diff);
- if (stack_size < MAX_SAVE_STACK)
- {
- if (stack_copy_size < stack_size)
+ /* If the string_chars struct is marked as free (i.e. the STRING
+ pointer is 0xFFFFFFFF) then this is an unused chunk of string
+ storage. (See below.) */
+
+ if (FREE_STRUCT_P (s_chars))
{
- stack_copy = (char *) xrealloc (stack_copy, stack_size);
- stack_copy_size = stack_size;
- }
+ fullsize = ((struct unused_string_chars *) s_chars)->fullsize;
+ pos += fullsize;
+ continue;
+ }
- memcpy (stack_copy,
- stack_diff > 0 ? stack_bottom : &stack_top_variable,
- stack_size);
- }
- }
-#endif /* MAX_SAVE_STACK > 0 */
+ string = s_chars->string;
+ /* Must be 32-bit aligned. */
+ assert ((((int) string) & 3) == 0);
- /* Do some totally ad-hoc resource clearing. */
- /* #### generalize this? */
- clear_event_resource ();
- cleanup_specifiers ();
+ size = string_length (string);
+ fullsize = STRING_FULLSIZE (size);
- /* Mark all the special slots that serve as the roots of accessibility. */
-
- { /* staticpro() */
- int i;
- for (i = 0; i < staticidx; i++)
- mark_object (*(staticvec[i]));
- for (i = 0; i < staticidx_nodump; i++)
- mark_object (*(staticvec_nodump[i]));
- }
-
- { /* GCPRO() */
- struct gcpro *tail;
- int i;
- for (tail = gcprolist; tail; tail = tail->next)
- for (i = 0; i < tail->nvars; i++)
- mark_object (tail->var[i]);
- }
-
- { /* specbind() */
- struct specbinding *bind;
- for (bind = specpdl; bind != specpdl_ptr; bind++)
- {
- mark_object (bind->symbol);
- mark_object (bind->old_value);
- }
- }
+ assert (!BIG_STRING_FULLSIZE_P (fullsize));
+ assert (string_data (string) == s_chars->chars);
+ pos += fullsize;
+ }
+ assert (pos == sb->pos);
+ }
+}
- {
- struct catchtag *catch;
- for (catch = catchlist; catch; catch = catch->next)
- {
- mark_object (catch->tag);
- mark_object (catch->val);
- }
- }
+#endif /* MULE && ERROR_CHECK_GC */
- {
- struct backtrace *backlist;
- for (backlist = backtrace_list; backlist; backlist = backlist->next)
- {
- int nargs = backlist->nargs;
- int i;
+/* Compactify string chars, relocating the reference to each --
+ free any empty string_chars_block we see. */
+static void
+compact_string_chars (void)
+{
+ struct string_chars_block *to_sb = first_string_chars_block;
+ int to_pos = 0;
+ struct string_chars_block *from_sb;
- mark_object (*backlist->function);
- if (nargs == UNEVALLED || nargs == MANY)
- mark_object (backlist->args[0]);
- else
- for (i = 0; i < nargs; i++)
- mark_object (backlist->args[i]);
- }
- }
+ /* Scan each existing string block sequentially, string by string. */
+ for (from_sb = first_string_chars_block; from_sb; from_sb = from_sb->next)
+ {
+ int from_pos = 0;
+ /* FROM_POS is the index of the next string in the block. */
+ while (from_pos < from_sb->pos)
+ {
+ struct string_chars *from_s_chars =
+ (struct string_chars *) &(from_sb->string_chars[from_pos]);
+ struct string_chars *to_s_chars;
+ struct Lisp_String *string;
+ int size;
+ int fullsize;
- mark_redisplay ();
- mark_profiling_info ();
+ /* If the string_chars struct is marked as free (i.e. the STRING
+ pointer is 0xFFFFFFFF) then this is an unused chunk of string
+ storage. This happens under Mule when a string's size changes
+ in such a way that its fullsize changes. (Strings can change
+ size because a different-length character can be substituted
+ for another character.) In this case, after the bogus string
+ pointer is the "fullsize" of this entry, i.e. how many bytes
+ to skip. */
- /* OK, now do the after-mark stuff. This is for things that
- are only marked when something else is marked (e.g. weak hash tables).
- There may be complex dependencies between such objects -- e.g.
- a weak hash table might be unmarked, but after processing a later
- weak hash table, the former one might get marked. So we have to
- iterate until nothing more gets marked. */
+ if (FREE_STRUCT_P (from_s_chars))
+ {
+ fullsize = ((struct unused_string_chars *) from_s_chars)->fullsize;
+ from_pos += fullsize;
+ continue;
+ }
- while (finish_marking_weak_hash_tables () > 0 ||
- finish_marking_weak_lists () > 0)
- ;
+ string = from_s_chars->string;
+ assert (!(FREE_STRUCT_P (string)));
- /* And prune (this needs to be called after everything else has been
- marked and before we do any sweeping). */
- /* #### this is somewhat ad-hoc and should probably be an object
- method */
- prune_weak_hash_tables ();
- prune_weak_lists ();
- prune_specifiers ();
- prune_syntax_tables ();
+ size = string_length (string);
+ fullsize = STRING_FULLSIZE (size);
- gc_sweep ();
+ if (BIG_STRING_FULLSIZE_P (fullsize))
+ abort ();
- consing_since_gc = 0;
-#ifndef DEBUG_XEMACS
- /* Allow you to set it really fucking low if you really want ... */
- if (gc_cons_threshold < 10000)
- gc_cons_threshold = 10000;
+ /* Just skip it if it isn't marked. */
+#ifdef LRECORD_STRING
+ if (! MARKED_RECORD_HEADER_P (&(string->lheader)))
+#else
+ if (!XMARKBIT (string->plist))
#endif
+ {
+ from_pos += fullsize;
+ continue;
+ }
- gc_in_progress = 0;
+ /* If it won't fit in what's left of TO_SB, close TO_SB out
+ and go on to the next string_chars_block. We know that TO_SB
+ cannot advance past FROM_SB here since FROM_SB is large enough
+ to currently contain this string. */
+ if ((to_pos + fullsize) > countof (to_sb->string_chars))
+ {
+ to_sb->pos = to_pos;
+ to_sb = to_sb->next;
+ to_pos = 0;
+ }
- /******* End of garbage collection ********/
+ /* Compute new address of this string
+ and update TO_POS for the space being used. */
+ to_s_chars = (struct string_chars *) &(to_sb->string_chars[to_pos]);
- run_hook_trapping_errors ("Error in post-gc-hook", Qpost_gc_hook);
+ /* Copy the string_chars to the new place. */
+ if (from_s_chars != to_s_chars)
+ memmove (to_s_chars, from_s_chars, fullsize);
- /* Now remove the GC cursor/message */
- if (!noninteractive)
- {
- if (cursor_changed)
- Fset_frame_pointer (make_frame (f), pre_gc_cursor);
- else if (!FRAME_STREAM_P (f))
- {
- char *msg = (STRINGP (Vgc_message)
- ? GETTEXT ((char *) XSTRING_DATA (Vgc_message))
- : 0);
+ /* Relocate FROM_S_CHARS's reference */
+ set_string_data (string, &(to_s_chars->chars[0]));
- /* Show "...done" only if the echo area would otherwise be empty. */
- if (NILP (clear_echo_area (selected_frame (),
- Qgarbage_collecting, 0)))
- {
- Lisp_Object args[2], whole_msg;
- args[0] = build_string (msg ? msg :
- GETTEXT ((CONST char *)
- gc_default_message));
- args[1] = build_string ("... done");
- whole_msg = Fconcat (2, args);
- echo_area_message (selected_frame (), (Bufbyte *) 0,
- whole_msg, 0, -1,
- Qgarbage_collecting);
- }
- }
+ from_pos += fullsize;
+ to_pos += fullsize;
+ }
}
- /* now stop inhibiting GC */
- unbind_to (speccount, Qnil);
+ /* Set current to the last string chars block still used and
+ free any that follow. */
+ {
+ struct string_chars_block *victim;
- if (!breathing_space)
- {
- breathing_space = malloc (4096 - MALLOC_OVERHEAD);
- }
+ for (victim = to_sb->next; victim; )
+ {
+ struct string_chars_block *next = victim->next;
+ xfree (victim);
+ victim = next;
+ }
- UNGCPRO;
- return;
+ current_string_chars_block = to_sb;
+ current_string_chars_block->pos = to_pos;
+ current_string_chars_block->next = 0;
+ }
}
-/* Debugging aids. */
+#if 1 /* Hack to debug missing purecopy's */
+static int debug_string_purity;
-static Lisp_Object
-gc_plist_hack (CONST char *name, int value, Lisp_Object tail)
+static void
+debug_string_purity_print (struct Lisp_String *p)
{
- /* C doesn't have local functions (or closures, or GC, or readable syntax,
- or portable numeric datatypes, or bit-vectors, or characters, or
- arrays, or exceptions, or ...) */
- return cons3 (intern (name), make_int (value), tail);
+ Charcount i;
+ Charcount s = string_char_length (p);
+ putc ('\"', stderr);
+ for (i = 0; i < s; i++)
+ {
+ Emchar ch = string_char (p, i);
+ if (ch < 32 || ch >= 126)
+ stderr_out ("\\%03o", ch);
+ else if (ch == '\\' || ch == '\"')
+ stderr_out ("\\%c", ch);
+ else
+ stderr_out ("%c", ch);
+ }
+ stderr_out ("\"\n");
}
+#endif /* 1 */
-#define HACK_O_MATIC(type, name, pl) do { \
- int s = 0; \
- struct type##_block *x = current_##type##_block; \
- while (x) { s += sizeof (*x) + MALLOC_OVERHEAD; x = x->prev; } \
- (pl) = gc_plist_hack ((name), s, (pl)); \
-} while (0)
-DEFUN ("garbage-collect", Fgarbage_collect, 0, 0, "", /*
-Reclaim storage for Lisp objects no longer needed.
-Return info on amount of space in use:
- ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
- (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
- PLIST)
- where `PLIST' is a list of alternating keyword/value pairs providing
- more detailed information.
-Garbage collection happens automatically if you cons more than
-`gc-cons-threshold' bytes of Lisp data since previous garbage collection.
-*/
- ())
+static void
+sweep_strings (void)
{
- Lisp_Object pl = Qnil;
- int i;
- int gc_count_vector_total_size = 0;
+ int num_small_used = 0, num_small_bytes = 0, num_bytes = 0;
+ int debug = debug_string_purity;
- garbage_collect_1 ();
+#ifdef LRECORD_STRING
- for (i = 0; i <= last_lrecord_type_index_assigned; i++)
- {
- if (lcrecord_stats[i].bytes_in_use != 0
- || lcrecord_stats[i].bytes_freed != 0
- || lcrecord_stats[i].instances_on_free_list != 0)
- {
- char buf [255];
- CONST char *name = lrecord_implementations_table[i]->name;
- int len = strlen (name);
- /* save this for the FSFmacs-compatible part of the summary */
- if (i == *lrecord_vector.lrecord_type_index)
- gc_count_vector_total_size =
- lcrecord_stats[i].bytes_in_use + lcrecord_stats[i].bytes_freed;
+# define MARKED_string_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
+# define UNMARK_string(ptr) \
+ do { struct Lisp_String *p = (ptr); \
+ int size = string_length (p); \
+ UNMARK_RECORD_HEADER (&(p->lheader)); \
+ num_bytes += size; \
+ if (!BIG_STRING_SIZE_P (size)) \
+ { num_small_bytes += size; \
+ num_small_used++; \
+ } \
+ if (debug) debug_string_purity_print (p); \
+ } while (0)
+# define ADDITIONAL_FREE_string(p) \
+ do { int size = string_length (p); \
+ if (BIG_STRING_SIZE_P (size)) \
+ xfree_1 (CHARS_TO_STRING_CHAR (string_data (p))); \
+ } while (0)
- sprintf (buf, "%s-storage", name);
- pl = gc_plist_hack (buf, lcrecord_stats[i].bytes_in_use, pl);
- /* Okay, simple pluralization check for `symbol-value-varalias' */
- if (name[len-1] == 's')
- sprintf (buf, "%ses-freed", name);
- else
- sprintf (buf, "%ss-freed", name);
- if (lcrecord_stats[i].instances_freed != 0)
- pl = gc_plist_hack (buf, lcrecord_stats[i].instances_freed, pl);
- if (name[len-1] == 's')
- sprintf (buf, "%ses-on-free-list", name);
- else
- sprintf (buf, "%ss-on-free-list", name);
- if (lcrecord_stats[i].instances_on_free_list != 0)
- pl = gc_plist_hack (buf, lcrecord_stats[i].instances_on_free_list,
- pl);
- if (name[len-1] == 's')
- sprintf (buf, "%ses-used", name);
- else
- sprintf (buf, "%ss-used", name);
- pl = gc_plist_hack (buf, lcrecord_stats[i].instances_in_use, pl);
- }
- }
-
- HACK_O_MATIC (extent, "extent-storage", pl);
- pl = gc_plist_hack ("extents-free", gc_count_num_extent_freelist, pl);
- pl = gc_plist_hack ("extents-used", gc_count_num_extent_in_use, pl);
- HACK_O_MATIC (event, "event-storage", pl);
- pl = gc_plist_hack ("events-free", gc_count_num_event_freelist, pl);
- pl = gc_plist_hack ("events-used", gc_count_num_event_in_use, pl);
- HACK_O_MATIC (marker, "marker-storage", pl);
- pl = gc_plist_hack ("markers-free", gc_count_num_marker_freelist, pl);
- pl = gc_plist_hack ("markers-used", gc_count_num_marker_in_use, pl);
-#ifdef LISP_FLOAT_TYPE
- HACK_O_MATIC (float, "float-storage", pl);
- pl = gc_plist_hack ("floats-free", gc_count_num_float_freelist, pl);
- pl = gc_plist_hack ("floats-used", gc_count_num_float_in_use, pl);
-#endif /* LISP_FLOAT_TYPE */
- HACK_O_MATIC (string, "string-header-storage", pl);
- pl = gc_plist_hack ("long-strings-total-length",
- gc_count_string_total_size
- - gc_count_short_string_total_size, pl);
- HACK_O_MATIC (string_chars, "short-string-storage", pl);
- pl = gc_plist_hack ("short-strings-total-length",
- gc_count_short_string_total_size, pl);
- pl = gc_plist_hack ("strings-free", gc_count_num_string_freelist, pl);
- pl = gc_plist_hack ("long-strings-used",
- gc_count_num_string_in_use
- - gc_count_num_short_string_in_use, pl);
- pl = gc_plist_hack ("short-strings-used",
- gc_count_num_short_string_in_use, pl);
-
- HACK_O_MATIC (compiled_function, "compiled-function-storage", pl);
- pl = gc_plist_hack ("compiled-functions-free",
- gc_count_num_compiled_function_freelist, pl);
- pl = gc_plist_hack ("compiled-functions-used",
- gc_count_num_compiled_function_in_use, pl);
+#else
- pl = gc_plist_hack ("bit-vector-storage", gc_count_bit_vector_storage, pl);
- pl = gc_plist_hack ("bit-vectors-total-length",
- gc_count_bit_vector_total_size, pl);
- pl = gc_plist_hack ("bit-vectors-used", gc_count_num_bit_vector_used, pl);
+# define MARKED_string_P(ptr) XMARKBIT ((ptr)->plist)
+# define UNMARK_string(ptr) \
+ do { struct Lisp_String *p = (ptr); \
+ int size = string_length (p); \
+ XUNMARK (p->plist); \
+ num_bytes += size; \
+ if (!BIG_STRING_SIZE_P (size)) \
+ { num_small_bytes += size; \
+ num_small_used++; \
+ } \
+ if (debug) debug_string_purity_print (p); \
+ } while (0)
+# define ADDITIONAL_FREE_string(p) \
+ do { int size = string_length (p); \
+ if (BIG_STRING_SIZE_P (size)) \
+ xfree_1 (CHARS_TO_STRING_CHAR (string_data (p))); \
+ } while (0)
- HACK_O_MATIC (symbol, "symbol-storage", pl);
- pl = gc_plist_hack ("symbols-free", gc_count_num_symbol_freelist, pl);
- pl = gc_plist_hack ("symbols-used", gc_count_num_symbol_in_use, pl);
+#endif /* ! LRECORD_STRING */
- HACK_O_MATIC (cons, "cons-storage", pl);
- pl = gc_plist_hack ("conses-free", gc_count_num_cons_freelist, pl);
- pl = gc_plist_hack ("conses-used", gc_count_num_cons_in_use, pl);
+ SWEEP_FIXED_TYPE_BLOCK (string, struct Lisp_String);
- /* The things we do for backwards-compatibility */
- return
- list6 (Fcons (make_int (gc_count_num_cons_in_use),
- make_int (gc_count_num_cons_freelist)),
- Fcons (make_int (gc_count_num_symbol_in_use),
- make_int (gc_count_num_symbol_freelist)),
- Fcons (make_int (gc_count_num_marker_in_use),
- make_int (gc_count_num_marker_freelist)),
- make_int (gc_count_string_total_size),
- make_int (gc_count_vector_total_size),
- pl);
+ gc_count_num_short_string_in_use = num_small_used;
+ gc_count_string_total_size = num_bytes;
+ gc_count_short_string_total_size = num_small_bytes;
}
-#undef HACK_O_MATIC
-
-DEFUN ("consing-since-gc", Fconsing_since_gc, 0, 0, "", /*
-Return the number of bytes consed since the last garbage collection.
-\"Consed\" is a misnomer in that this actually counts allocation
-of all different kinds of objects, not just conses.
-If this value exceeds `gc-cons-threshold', a garbage collection happens.
-*/
- ())
-{
- return make_int (consing_since_gc);
-}
-DEFUN ("memory-limit", Fmemory_limit, 0, 0, "", /*
-Return the address of the last byte Emacs has allocated, divided by 1024.
-This may be helpful in debugging Emacs's memory usage.
-The value is divided by 1024 to make sure it will fit in a lisp integer.
-*/
- ())
+/* I hate duplicating all this crap! */
+static int
+marked_p (Lisp_Object obj)
{
- return make_int ((EMACS_INT) sbrk (0) / 1024);
+ if (EQ (obj, Qnull_pointer)) return 1;
+ if (!POINTER_TYPE_P (XGCTYPE (obj))) return 1;
+ if (PURIFIED (XPNTR (obj))) return 1;
+ switch (XGCTYPE (obj))
+ {
+#ifndef LRECORD_CONS
+ case Lisp_Type_Cons:
+ return XMARKBIT (XCAR (obj));
+#endif
+ case Lisp_Type_Record:
+ return MARKED_RECORD_HEADER_P (XRECORD_LHEADER (obj));
+#ifndef LRECORD_STRING
+ case Lisp_Type_String:
+ return XMARKBIT (XSTRING (obj)->plist);
+#endif /* ! LRECORD_STRING */
+#ifndef LRECORD_VECTOR
+ case Lisp_Type_Vector:
+ return XVECTOR_LENGTH (obj) < 0;
+#endif /* !LRECORD_VECTOR */
+#ifndef LRECORD_SYMBOL
+ case Lisp_Type_Symbol:
+ return XMARKBIT (XSYMBOL (obj)->plist);
+#endif
+ default:
+ abort ();
+ }
+ return 0; /* suppress compiler warning */
}
-
-\f
-int
-object_dead_p (Lisp_Object obj)
+static void
+gc_sweep (void)
{
- return ((BUFFERP (obj) && !BUFFER_LIVE_P (XBUFFER (obj))) ||
- (FRAMEP (obj) && !FRAME_LIVE_P (XFRAME (obj))) ||
- (WINDOWP (obj) && !WINDOW_LIVE_P (XWINDOW (obj))) ||
- (DEVICEP (obj) && !DEVICE_LIVE_P (XDEVICE (obj))) ||
- (CONSOLEP (obj) && !CONSOLE_LIVE_P (XCONSOLE (obj))) ||
- (EVENTP (obj) && !EVENT_LIVE_P (XEVENT (obj))) ||
- (EXTENTP (obj) && !EXTENT_LIVE_P (XEXTENT (obj))));
-}
+ /* Free all unmarked records. Do this at the very beginning,
+ before anything else, so that the finalize methods can safely
+ examine items in the objects. sweep_lcrecords_1() makes
+ sure to call all the finalize methods *before* freeing anything,
+ to complete the safety. */
+ {
+ int ignored;
+ sweep_lcrecords_1 (&all_lcrecords, &ignored);
+ }
-#ifdef MEMORY_USAGE_STATS
+ compact_string_chars ();
-/* Attempt to determine the actual amount of space that is used for
- the block allocated starting at PTR, supposedly of size "CLAIMED_SIZE".
+ /* Finalize methods below (called through the ADDITIONAL_FREE_foo
+ macros) must be *extremely* careful to make sure they're not
+ referencing freed objects. The only two existing finalize
+ methods (for strings and markers) pass muster -- the string
+ finalizer doesn't look at anything but its own specially-
+ created block, and the marker finalizer only looks at live
+ buffers (which will never be freed) and at the markers before
+ and after it in the chain (which, by induction, will never be
+ freed because if so, they would have already removed themselves
+ from the chain). */
- It seems that the following holds:
+ /* Put all unmarked strings on free list, free'ing the string chars
+ of large unmarked strings */
+ sweep_strings ();
- 1. When using the old allocator (malloc.c):
+ /* Put all unmarked conses on free list */
+ sweep_conses ();
- -- blocks are always allocated in chunks of powers of two. For
- each block, there is an overhead of 8 bytes if rcheck is not
- defined, 20 bytes if it is defined. In other words, a
- one-byte allocation needs 8 bytes of overhead for a total of
- 9 bytes, and needs to have 16 bytes of memory chunked out for
- it.
+#ifndef LRECORD_VECTOR
+ /* Free all unmarked vectors */
+ sweep_vectors_1 (&all_vectors,
+ &gc_count_num_vector_used, &gc_count_vector_total_size,
+ &gc_count_vector_storage);
+#endif
- 2. When using the new allocator (gmalloc.c):
+ /* Free all unmarked bit vectors */
+ sweep_bit_vectors_1 (&all_bit_vectors,
+ &gc_count_num_bit_vector_used,
+ &gc_count_bit_vector_total_size,
+ &gc_count_bit_vector_storage);
- -- blocks are always allocated in chunks of powers of two up
- to 4096 bytes. Larger blocks are allocated in chunks of
- an integral multiple of 4096 bytes. The minimum block
- size is 2*sizeof (void *), or 16 bytes if SUNOS_LOCALTIME_BUG
- is defined. There is no per-block overhead, but there
- is an overhead of 3*sizeof (size_t) for each 4096 bytes
- allocated.
+ /* Free all unmarked compiled-function objects */
+ sweep_compiled_functions ();
- 3. When using the system malloc, anything goes, but they are
- generally slower and more space-efficient than the GNU
- allocators. One possibly reasonable assumption to make
- for want of better data is that sizeof (void *), or maybe
- 2 * sizeof (void *), is required as overhead and that
- blocks are allocated in the minimum required size except
- that some minimum block size is imposed (e.g. 16 bytes). */
+#ifdef LISP_FLOAT_TYPE
+ /* Put all unmarked floats on free list */
+ sweep_floats ();
+#endif
-size_t
-malloced_storage_size (void *ptr, size_t claimed_size,
- struct overhead_stats *stats)
-{
- size_t orig_claimed_size = claimed_size;
+ /* Put all unmarked symbols on free list */
+ sweep_symbols ();
-#ifdef GNU_MALLOC
+ /* Put all unmarked extents on free list */
+ sweep_extents ();
- if (claimed_size < 2 * sizeof (void *))
- claimed_size = 2 * sizeof (void *);
-# ifdef SUNOS_LOCALTIME_BUG
- if (claimed_size < 16)
- claimed_size = 16;
-# endif
- if (claimed_size < 4096)
- {
- int log = 1;
+ /* Put all unmarked markers on free list.
+ Dechain each one first from the buffer into which it points. */
+ sweep_markers ();
- /* compute the log base two, more or less, then use it to compute
- the block size needed. */
- claimed_size--;
- /* It's big, it's heavy, it's wood! */
- while ((claimed_size /= 2) != 0)
- ++log;
- claimed_size = 1;
- /* It's better than bad, it's good! */
- while (log > 0)
- {
- claimed_size *= 2;
- log--;
- }
- /* We have to come up with some average about the amount of
- blocks used. */
- if ((size_t) (rand () & 4095) < claimed_size)
- claimed_size += 3 * sizeof (void *);
- }
- else
- {
- claimed_size += 4095;
- claimed_size &= ~4095;
- claimed_size += (claimed_size / 4096) * 3 * sizeof (size_t);
- }
+ sweep_events ();
-#elif defined (SYSTEM_MALLOC)
+}
+\f
+/* Clearing for disksave. */
- if (claimed_size < 16)
- claimed_size = 16;
- claimed_size += 2 * sizeof (void *);
+void
+disksave_object_finalization (void)
+{
+ /* It's important that certain information from the environment not get
+ dumped with the executable (pathnames, environment variables, etc.).
+ To make it easier to tell when this has happend with strings(1) we
+ clear some known-to-be-garbage blocks of memory, so that leftover
+ results of old evaluation don't look like potential problems.
+ But first we set some notable variables to nil and do one more GC,
+ to turn those strings into garbage.
+ */
-#else /* old GNU allocator */
+ /* Yeah, this list is pretty ad-hoc... */
+ Vprocess_environment = Qnil;
+ Vexec_directory = Qnil;
+ Vdata_directory = Qnil;
+ Vsite_directory = Qnil;
+ Vdoc_directory = Qnil;
+ Vconfigure_info_directory = Qnil;
+ Vexec_path = Qnil;
+ Vload_path = Qnil;
+ /* Vdump_load_path = Qnil; */
+ uncache_home_directory();
-# ifdef rcheck /* #### may not be defined here */
- claimed_size += 20;
-# else
- claimed_size += 8;
-# endif
- {
- int log = 1;
+#if defined(LOADHIST) && !(defined(LOADHIST_DUMPED) || \
+ defined(LOADHIST_BUILTIN))
+ Vload_history = Qnil;
+#endif
+ Vshell_file_name = Qnil;
- /* compute the log base two, more or less, then use it to compute
- the block size needed. */
- claimed_size--;
- /* It's big, it's heavy, it's wood! */
- while ((claimed_size /= 2) != 0)
- ++log;
- claimed_size = 1;
- /* It's better than bad, it's good! */
- while (log > 0)
+ garbage_collect_1 ();
+
+ /* Run the disksave finalization methods of all live objects. */
+ disksave_object_finalization_1 ();
+
+#if 0 /* I don't see any point in this. The purespace starts out all 0's */
+ /* Zero out the unused portion of purespace */
+ if (!pure_lossage)
+ memset ( (char *) (PUREBEG + pure_bytes_used), 0,
+ (((char *) (PUREBEG + get_PURESIZE())) -
+ ((char *) (PUREBEG + pure_bytes_used))));
+#endif
+
+ /* Zero out the uninitialized (really, unused) part of the containers
+ for the live strings. */
+ {
+ struct string_chars_block *scb;
+ for (scb = first_string_chars_block; scb; scb = scb->next)
{
- claimed_size *= 2;
- log--;
+ int count = sizeof (scb->string_chars) - scb->pos;
+
+ assert (count >= 0 && count < STRING_CHARS_BLOCK_SIZE);
+ if (count != 0) {
+ /* from the block's fill ptr to the end */
+ memset ((scb->string_chars + scb->pos), 0, count);
+ }
}
}
-#endif /* old GNU allocator */
+ /* There, that ought to be enough... */
- if (stats)
- {
- stats->was_requested += orig_claimed_size;
- stats->malloc_overhead += claimed_size - orig_claimed_size;
- }
- return claimed_size;
}
-size_t
-fixed_type_block_overhead (size_t size)
+\f
+Lisp_Object
+restore_gc_inhibit (Lisp_Object val)
{
- size_t per_block = TYPE_ALLOC_SIZE (cons, unsigned char);
- size_t overhead = 0;
- size_t storage_size = malloced_storage_size (0, per_block, 0);
- while (size >= per_block)
- {
- size -= per_block;
- overhead += sizeof (void *) + per_block - storage_size;
- }
- if (rand () % per_block < size)
- overhead += sizeof (void *) + per_block - storage_size;
- return overhead;
+ gc_currently_forbidden = XINT (val);
+ return val;
}
-#endif /* MEMORY_USAGE_STATS */
+/* Maybe we want to use this when doing a "panic" gc after memory_full()? */
+static int gc_hooks_inhibited;
\f
-/* Initialization */
void
-reinit_alloc_once_early (void)
+garbage_collect_1 (void)
{
- gc_generation_number[0] = 0;
- /* purify_flag 1 is correct even if CANNOT_DUMP.
- * loadup.el will set to nil at end. */
- purify_flag = 1;
- breathing_space = 0;
- XSETINT (all_bit_vectors, 0); /* Qzero may not be set yet. */
- XSETINT (Vgc_message, 0);
- all_lcrecords = 0;
- ignore_malloc_warnings = 1;
-#ifdef DOUG_LEA_MALLOC
- mallopt (M_TRIM_THRESHOLD, 128*1024); /* trim threshold */
- mallopt (M_MMAP_THRESHOLD, 64*1024); /* mmap threshold */
-#if 0 /* Moved to emacs.c */
- mallopt (M_MMAP_MAX, 64); /* max. number of mmap'ed areas */
-#endif
-#endif
- init_string_alloc ();
- init_string_chars_alloc ();
- init_cons_alloc ();
- init_symbol_alloc ();
- init_compiled_function_alloc ();
-#ifdef LISP_FLOAT_TYPE
- init_float_alloc ();
-#endif /* LISP_FLOAT_TYPE */
- init_marker_alloc ();
- init_extent_alloc ();
- init_event_alloc ();
-
- ignore_malloc_warnings = 0;
+ char stack_top_variable;
+ extern char *stack_bottom;
+ int i;
+ struct frame *f;
+ int speccount;
+ int cursor_changed;
+ Lisp_Object pre_gc_cursor;
+ struct gcpro gcpro1;
- staticidx_nodump = 0;
- dumpstructidx = 0;
- pdump_wireidx = 0;
+ if (gc_in_progress
+ || gc_currently_forbidden
+ || in_display
+ || preparing_for_armageddon)
+ return;
- consing_since_gc = 0;
-#if 1
- gc_cons_threshold = 500000; /* XEmacs change */
-#else
- gc_cons_threshold = 15000; /* debugging */
-#endif
-#ifdef VIRT_ADDR_VARIES
- malloc_sbrk_unused = 1<<22; /* A large number */
- malloc_sbrk_used = 100000; /* as reasonable as any number */
-#endif /* VIRT_ADDR_VARIES */
- lrecord_uid_counter = 259;
- debug_string_purity = 0;
- gcprolist = 0;
+ pre_gc_cursor = Qnil;
+ cursor_changed = 0;
- gc_currently_forbidden = 0;
- gc_hooks_inhibited = 0;
+ /* This function cannot be called inside GC so we move to after the */
+ /* above tests */
+ f = selected_frame ();
-#ifdef ERROR_CHECK_TYPECHECK
- ERROR_ME.really_unlikely_name_to_have_accidentally_in_a_non_errb_structure =
- 666;
- ERROR_ME_NOT.
- really_unlikely_name_to_have_accidentally_in_a_non_errb_structure = 42;
- ERROR_ME_WARN.
- really_unlikely_name_to_have_accidentally_in_a_non_errb_structure =
- 3333632;
-#endif /* ERROR_CHECK_TYPECHECK */
-}
+ GCPRO1 (pre_gc_cursor);
-void
-init_alloc_once_early (void)
-{
- int iii;
+ /* Very important to prevent GC during any of the following
+ stuff that might run Lisp code; otherwise, we'll likely
+ have infinite GC recursion. */
+ speccount = specpdl_depth ();
+ record_unwind_protect (restore_gc_inhibit,
+ make_int (gc_currently_forbidden));
+ gc_currently_forbidden = 1;
- reinit_alloc_once_early ();
+ if (!gc_hooks_inhibited)
+ run_hook_trapping_errors ("Error in pre-gc-hook", Qpre_gc_hook);
- last_lrecord_type_index_assigned = -1;
- for (iii = 0; iii < countof (lrecord_implementations_table); iii++)
+ /* Now show the GC cursor/message. */
+ if (!noninteractive)
{
- lrecord_implementations_table[iii] = 0;
- }
+ if (FRAME_WIN_P (f))
+ {
+ Lisp_Object frame = make_frame (f);
+ Lisp_Object cursor = glyph_image_instance (Vgc_pointer_glyph,
+ FRAME_SELECTED_WINDOW (f),
+ ERROR_ME_NOT, 1);
+ pre_gc_cursor = f->pointer;
+ if (POINTER_IMAGE_INSTANCEP (cursor)
+ /* don't change if we don't know how to change back. */
+ && POINTER_IMAGE_INSTANCEP (pre_gc_cursor))
+ {
+ cursor_changed = 1;
+ Fset_frame_pointer (frame, cursor);
+ }
+ }
- /*
- * All the staticly
- * defined subr lrecords were initialized with lheader->type == 0.
- * See subr_lheader_initializer in lisp.h. Force type index 0 to be
- * assigned to lrecord_subr so that those predefined indexes match
- * reality.
- */
- lrecord_type_index (&lrecord_subr);
- assert (*(lrecord_subr.lrecord_type_index) == 0);
- /*
- * The same is true for symbol_value_forward objects, except the
- * type is 1.
- */
- lrecord_type_index (&lrecord_symbol_value_forward);
- assert (*(lrecord_symbol_value_forward.lrecord_type_index) == 1);
+ /* Don't print messages to the stream device. */
+ if (!cursor_changed && !FRAME_STREAM_P (f))
+ {
+ char *msg = (STRINGP (Vgc_message)
+ ? GETTEXT ((char *) XSTRING_DATA (Vgc_message))
+ : 0);
+ Lisp_Object args[2], whole_msg;
+ args[0] = build_string (msg ? msg :
+ GETTEXT ((CONST char *) gc_default_message));
+ args[1] = build_string ("...");
+ whole_msg = Fconcat (2, args);
+ echo_area_message (f, (Bufbyte *) 0, whole_msg, 0, -1,
+ Qgarbage_collecting);
+ }
+ }
- staticidx = 0;
-}
+ /***** Now we actually start the garbage collection. */
-int pure_bytes_used = 0;
+ gc_in_progress = 1;
-void
-reinit_alloc (void)
-{
- gcprolist = 0;
-}
+ gc_generation_number[0]++;
-void
-syms_of_alloc (void)
-{
- defsymbol (&Qpre_gc_hook, "pre-gc-hook");
- defsymbol (&Qpost_gc_hook, "post-gc-hook");
- defsymbol (&Qgarbage_collecting, "garbage-collecting");
+#if MAX_SAVE_STACK > 0
- DEFSUBR (Fcons);
- DEFSUBR (Flist);
- DEFSUBR (Fvector);
- DEFSUBR (Fbit_vector);
- DEFSUBR (Fmake_byte_code);
- DEFSUBR (Fmake_list);
- DEFSUBR (Fmake_vector);
- DEFSUBR (Fmake_bit_vector);
- DEFSUBR (Fmake_string);
- DEFSUBR (Fstring);
- DEFSUBR (Fmake_symbol);
- DEFSUBR (Fmake_marker);
- DEFSUBR (Fpurecopy);
- DEFSUBR (Fgarbage_collect);
- DEFSUBR (Fmemory_limit);
- DEFSUBR (Fconsing_since_gc);
-}
+ /* Save a copy of the contents of the stack, for debugging. */
+ if (!purify_flag)
+ {
+ /* Static buffer in which we save a copy of the C stack at each GC. */
+ static char *stack_copy;
+ static size_t stack_copy_size;
-void
-vars_of_alloc (void)
-{
- DEFVAR_INT ("gc-cons-threshold", &gc_cons_threshold /*
-*Number of bytes of consing between garbage collections.
-\"Consing\" is a misnomer in that this actually counts allocation
-of all different kinds of objects, not just conses.
-Garbage collection can happen automatically once this many bytes have been
-allocated since the last garbage collection. All data types count.
-
-Garbage collection happens automatically when `eval' or `funcall' are
-called. (Note that `funcall' is called implicitly as part of evaluation.)
-By binding this temporarily to a large number, you can effectively
-prevent garbage collection during a part of the program.
+ ptrdiff_t stack_diff = &stack_top_variable - stack_bottom;
+ size_t stack_size = (stack_diff > 0 ? stack_diff : -stack_diff);
+ if (stack_size < MAX_SAVE_STACK)
+ {
+ if (stack_copy_size < stack_size)
+ {
+ stack_copy = (char *) xrealloc (stack_copy, stack_size);
+ stack_copy_size = stack_size;
+ }
-See also `consing-since-gc'.
-*/ );
+ memcpy (stack_copy,
+ stack_diff > 0 ? stack_bottom : &stack_top_variable,
+ stack_size);
+ }
+ }
+#endif /* MAX_SAVE_STACK > 0 */
- DEFVAR_INT ("pure-bytes-used", &pure_bytes_used /*
-Number of bytes of sharable Lisp data allocated so far.
-*/ );
+ /* Do some totally ad-hoc resource clearing. */
+ /* #### generalize this? */
+ clear_event_resource ();
+ cleanup_specifiers ();
-#if 0
- DEFVAR_INT ("data-bytes-used", &malloc_sbrk_used /*
-Number of bytes of unshared memory allocated in this session.
-*/ );
+ /* Mark all the special slots that serve as the roots of accessibility. */
+ {
+ struct gcpro *tail;
+ struct catchtag *catch;
+ struct backtrace *backlist;
+ struct specbinding *bind;
- DEFVAR_INT ("data-bytes-free", &malloc_sbrk_unused /*
-Number of bytes of unshared memory remaining available in this session.
-*/ );
+ for (i = 0; i < staticidx; i++)
+ {
+#ifdef GDB_SUCKS
+ printf ("%d\n", i);
+ debug_print (*staticvec[i]);
#endif
+ mark_object (*(staticvec[i]));
+ }
-#ifdef DEBUG_XEMACS
- DEFVAR_INT ("debug-allocation", &debug_allocation /*
-If non-zero, print out information to stderr about all objects allocated.
-See also `debug-allocation-backtrace-length'.
-*/ );
- debug_allocation = 0;
+ for (tail = gcprolist; tail; tail = tail->next)
+ {
+ for (i = 0; i < tail->nvars; i++)
+ mark_object (tail->var[i]);
+ }
- DEFVAR_INT ("debug-allocation-backtrace-length",
- &debug_allocation_backtrace_length /*
-Length (in stack frames) of short backtrace printed out by `debug-allocation'.
-*/ );
- debug_allocation_backtrace_length = 2;
+ for (bind = specpdl; bind != specpdl_ptr; bind++)
+ {
+ mark_object (bind->symbol);
+ mark_object (bind->old_value);
+ }
+
+ for (catch = catchlist; catch; catch = catch->next)
+ {
+ mark_object (catch->tag);
+ mark_object (catch->val);
+ }
+
+ for (backlist = backtrace_list; backlist; backlist = backlist->next)
+ {
+ int nargs = backlist->nargs;
+
+ mark_object (*backlist->function);
+ if (nargs == UNEVALLED || nargs == MANY)
+ mark_object (backlist->args[0]);
+ else
+ for (i = 0; i < nargs; i++)
+ mark_object (backlist->args[i]);
+ }
+
+ mark_redisplay (mark_object);
+ mark_profiling_info (mark_object);
+ }
+
+ /* OK, now do the after-mark stuff. This is for things that
+ are only marked when something else is marked (e.g. weak hashtables).
+ There may be complex dependencies between such objects -- e.g.
+ a weak hashtable might be unmarked, but after processing a later
+ weak hashtable, the former one might get marked. So we have to
+ iterate until nothing more gets marked. */
+ {
+ int did_mark;
+ /* Need to iterate until there's nothing more to mark, in case
+ of chains of mark dependencies. */
+ do
+ {
+ did_mark = 0;
+ did_mark += !!finish_marking_weak_hashtables (marked_p, mark_object);
+ did_mark += !!finish_marking_weak_lists (marked_p, mark_object);
+ }
+ while (did_mark);
+ }
+
+ /* And prune (this needs to be called after everything else has been
+ marked and before we do any sweeping). */
+ /* #### this is somewhat ad-hoc and should probably be an object
+ method */
+ prune_weak_hashtables (marked_p);
+ prune_weak_lists (marked_p);
+ prune_specifiers (marked_p);
+ prune_syntax_tables (marked_p);
+
+ gc_sweep ();
+
+ consing_since_gc = 0;
+#ifndef DEBUG_XEMACS
+ /* Allow you to set it really fucking low if you really want ... */
+ if (gc_cons_threshold < 10000)
+ gc_cons_threshold = 10000;
#endif
- DEFVAR_BOOL ("purify-flag", &purify_flag /*
-Non-nil means loading Lisp code in order to dump an executable.
-This means that certain objects should be allocated in readonly space.
-*/ );
+ gc_in_progress = 0;
- DEFVAR_LISP ("pre-gc-hook", &Vpre_gc_hook /*
-Function or functions to be run just before each garbage collection.
-Interrupts, garbage collection, and errors are inhibited while this hook
-runs, so be extremely careful in what you add here. In particular, avoid
-consing, and do not interact with the user.
-*/ );
- Vpre_gc_hook = Qnil;
+ /******* End of garbage collection ********/
- DEFVAR_LISP ("post-gc-hook", &Vpost_gc_hook /*
-Function or functions to be run just after each garbage collection.
-Interrupts, garbage collection, and errors are inhibited while this hook
-runs, so be extremely careful in what you add here. In particular, avoid
-consing, and do not interact with the user.
-*/ );
- Vpost_gc_hook = Qnil;
+ run_hook_trapping_errors ("Error in post-gc-hook", Qpost_gc_hook);
- DEFVAR_LISP ("gc-message", &Vgc_message /*
-String to print to indicate that a garbage collection is in progress.
-This is printed in the echo area. If the selected frame is on a
-window system and `gc-pointer-glyph' specifies a value (i.e. a pointer
-image instance) in the domain of the selected frame, the mouse pointer
-will change instead of this message being printed.
-*/ );
- Vgc_message = build_string (gc_default_message);
+ /* Now remove the GC cursor/message */
+ if (!noninteractive)
+ {
+ if (cursor_changed)
+ Fset_frame_pointer (make_frame (f), pre_gc_cursor);
+ else if (!FRAME_STREAM_P (f))
+ {
+ char *msg = (STRINGP (Vgc_message)
+ ? GETTEXT ((char *) XSTRING_DATA (Vgc_message))
+ : 0);
- DEFVAR_LISP ("gc-pointer-glyph", &Vgc_pointer_glyph /*
-Pointer glyph used to indicate that a garbage collection is in progress.
-If the selected window is on a window system and this glyph specifies a
-value (i.e. a pointer image instance) in the domain of the selected
-window, the pointer will be changed as specified during garbage collection.
-Otherwise, a message will be printed in the echo area, as controlled
-by `gc-message'.
-*/ );
-}
+ /* Show "...done" only if the echo area would otherwise be empty. */
+ if (NILP (clear_echo_area (selected_frame (),
+ Qgarbage_collecting, 0)))
+ {
+ Lisp_Object args[2], whole_msg;
+ args[0] = build_string (msg ? msg :
+ GETTEXT ((CONST char *)
+ gc_default_message));
+ args[1] = build_string ("... done");
+ whole_msg = Fconcat (2, args);
+ echo_area_message (selected_frame (), (Bufbyte *) 0,
+ whole_msg, 0, -1,
+ Qgarbage_collecting);
+ }
+ }
+ }
-void
-complex_vars_of_alloc (void)
-{
- Vgc_pointer_glyph = Fmake_glyph_internal (Qpointer);
+ /* now stop inhibiting GC */
+ unbind_to (speccount, Qnil);
+
+ if (!breathing_space)
+ {
+ breathing_space = malloc (4096 - MALLOC_OVERHEAD);
+ }
+
+ UNGCPRO;
+ return;
}
+#ifdef EMACS_BTL
+ /* This isn't actually called. BTL recognizes the stack frame of the top
+ of the garbage collector by noting that PC is between &garbage_collect_1
+ and &BTL_after_garbage_collect_1_stub. So this fn must be right here.
+ There's not any other way to know the address of the end of a function.
+ */
+void BTL_after_garbage_collect_1_stub () { abort (); }
+#endif /* EMACS_BTL */
-#ifdef PDUMP
-
-/* The structure of the file
- *
- * 0 - header
- * 256 - dumped objects
- * stab_offset - nb_staticpro*(Lisp_Object *) from staticvec
- * - nb_staticpro*(relocated Lisp_Object) pointed to by staticpro
- * - nb_structdmp*pair(void *, adr) for pointers to structures
- * - lrecord_implementations_table[]
- * - relocation table
- * - wired variable address/value couples with the count preceding the list
- */
-typedef struct
-{
- char signature[8];
- EMACS_UINT stab_offset;
- EMACS_UINT reloc_address;
- int nb_staticpro;
- int nb_structdmp;
- int last_type;
-} dump_header;
-
-char *pdump_start, *pdump_end;
-
-static const unsigned char align_table[256] =
-{
- 8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
-};
+/* Debugging aids. */
-typedef struct pdump_entry_list_elmt
+static Lisp_Object
+gc_plist_hack (CONST char *name, int value, Lisp_Object tail)
{
- struct pdump_entry_list_elmt *next;
- const void *obj;
- size_t size;
- int count;
- int is_lrecord;
- EMACS_INT save_offset;
-} pdump_entry_list_elmt;
+ /* C doesn't have local functions (or closures, or GC, or readable syntax,
+ or portable numeric datatypes, or bit-vectors, or characters, or
+ arrays, or exceptions, or ...) */
+ return cons3 (intern (name), make_int (value), tail);
+}
-typedef struct
-{
- pdump_entry_list_elmt *first;
- int align;
- int count;
-} pdump_entry_list;
+#define HACK_O_MATIC(type, name, pl) \
+ { \
+ int s = 0; \
+ struct type##_block *x = current_##type##_block; \
+ while (x) { s += sizeof (*x) + MALLOC_OVERHEAD; x = x->prev; } \
+ (pl) = gc_plist_hack ((name), s, (pl)); \
+ }
-typedef struct pdump_struct_list_elmt
+DEFUN ("garbage-collect", Fgarbage_collect, 0, 0, "", /*
+Reclaim storage for Lisp objects no longer needed.
+Return info on amount of space in use:
+ ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
+ (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
+ PLIST)
+ where `PLIST' is a list of alternating keyword/value pairs providing
+ more detailed information.
+Garbage collection happens automatically if you cons more than
+`gc-cons-threshold' bytes of Lisp data since previous garbage collection.
+*/
+ ())
{
- pdump_entry_list list;
- const struct struct_description *sdesc;
-} pdump_struct_list_elmt;
+ Lisp_Object pl = Qnil;
+ int i;
+#ifdef LRECORD_VECTOR
+ int gc_count_vector_total_size = 0;
+#endif
-typedef struct
-{
- pdump_struct_list_elmt *list;
- int count;
- int size;
-} pdump_struct_list;
+ if (purify_flag && pure_lossage)
+ return Qnil;
-static pdump_entry_list pdump_object_table[256];
-static pdump_entry_list pdump_opaque_data_list;
-static pdump_struct_list pdump_struct_table;
-static pdump_entry_list_elmt *pdump_qnil;
+ garbage_collect_1 ();
+
+ for (i = 0; i < last_lrecord_type_index_assigned; i++)
+ {
+ if (lcrecord_stats[i].bytes_in_use != 0
+ || lcrecord_stats[i].bytes_freed != 0
+ || lcrecord_stats[i].instances_on_free_list != 0)
+ {
+ char buf [255];
+ CONST char *name = lrecord_implementations_table[i]->name;
+ int len = strlen (name);
+#ifdef LRECORD_VECTOR
+ /* save this for the FSFmacs-compatible part of the summary */
+ if (i == *lrecord_vector[0].lrecord_type_index)
+ gc_count_vector_total_size =
+ lcrecord_stats[i].bytes_in_use + lcrecord_stats[i].bytes_freed;
+#endif
+ sprintf (buf, "%s-storage", name);
+ pl = gc_plist_hack (buf, lcrecord_stats[i].bytes_in_use, pl);
+ /* Okay, simple pluralization check for `symbol-value-varalias' */
+ if (name[len-1] == 's')
+ sprintf (buf, "%ses-freed", name);
+ else
+ sprintf (buf, "%ss-freed", name);
+ if (lcrecord_stats[i].instances_freed != 0)
+ pl = gc_plist_hack (buf, lcrecord_stats[i].instances_freed, pl);
+ if (name[len-1] == 's')
+ sprintf (buf, "%ses-on-free-list", name);
+ else
+ sprintf (buf, "%ss-on-free-list", name);
+ if (lcrecord_stats[i].instances_on_free_list != 0)
+ pl = gc_plist_hack (buf, lcrecord_stats[i].instances_on_free_list,
+ pl);
+ if (name[len-1] == 's')
+ sprintf (buf, "%ses-used", name);
+ else
+ sprintf (buf, "%ss-used", name);
+ pl = gc_plist_hack (buf, lcrecord_stats[i].instances_in_use, pl);
+ }
+ }
+
+ HACK_O_MATIC (extent, "extent-storage", pl);
+ pl = gc_plist_hack ("extents-free", gc_count_num_extent_freelist, pl);
+ pl = gc_plist_hack ("extents-used", gc_count_num_extent_in_use, pl);
+ HACK_O_MATIC (event, "event-storage", pl);
+ pl = gc_plist_hack ("events-free", gc_count_num_event_freelist, pl);
+ pl = gc_plist_hack ("events-used", gc_count_num_event_in_use, pl);
+ HACK_O_MATIC (marker, "marker-storage", pl);
+ pl = gc_plist_hack ("markers-free", gc_count_num_marker_freelist, pl);
+ pl = gc_plist_hack ("markers-used", gc_count_num_marker_in_use, pl);
+#ifdef LISP_FLOAT_TYPE
+ HACK_O_MATIC (float, "float-storage", pl);
+ pl = gc_plist_hack ("floats-free", gc_count_num_float_freelist, pl);
+ pl = gc_plist_hack ("floats-used", gc_count_num_float_in_use, pl);
+#endif /* LISP_FLOAT_TYPE */
+ HACK_O_MATIC (string, "string-header-storage", pl);
+ pl = gc_plist_hack ("long-strings-total-length",
+ gc_count_string_total_size
+ - gc_count_short_string_total_size, pl);
+ HACK_O_MATIC (string_chars, "short-string-storage", pl);
+ pl = gc_plist_hack ("short-strings-total-length",
+ gc_count_short_string_total_size, pl);
+ pl = gc_plist_hack ("strings-free", gc_count_num_string_freelist, pl);
+ pl = gc_plist_hack ("long-strings-used",
+ gc_count_num_string_in_use
+ - gc_count_num_short_string_in_use, pl);
+ pl = gc_plist_hack ("short-strings-used",
+ gc_count_num_short_string_in_use, pl);
+
+ HACK_O_MATIC (compiled_function, "compiled-function-storage", pl);
+ pl = gc_plist_hack ("compiled-functions-free",
+ gc_count_num_compiled_function_freelist, pl);
+ pl = gc_plist_hack ("compiled-functions-used",
+ gc_count_num_compiled_function_in_use, pl);
+
+#ifndef LRECORD_VECTOR
+ pl = gc_plist_hack ("vector-storage", gc_count_vector_storage, pl);
+ pl = gc_plist_hack ("vectors-total-length",
+ gc_count_vector_total_size, pl);
+ pl = gc_plist_hack ("vectors-used", gc_count_num_vector_used, pl);
+#endif
+
+ pl = gc_plist_hack ("bit-vector-storage", gc_count_bit_vector_storage, pl);
+ pl = gc_plist_hack ("bit-vectors-total-length",
+ gc_count_bit_vector_total_size, pl);
+ pl = gc_plist_hack ("bit-vectors-used", gc_count_num_bit_vector_used, pl);
-static int pdump_alert_undump_object[256];
+ HACK_O_MATIC (symbol, "symbol-storage", pl);
+ pl = gc_plist_hack ("symbols-free", gc_count_num_symbol_freelist, pl);
+ pl = gc_plist_hack ("symbols-used", gc_count_num_symbol_in_use, pl);
-static unsigned long cur_offset;
-static size_t max_size;
-static int pdump_fd;
-static void *pdump_buf;
+ HACK_O_MATIC (cons, "cons-storage", pl);
+ pl = gc_plist_hack ("conses-free", gc_count_num_cons_freelist, pl);
+ pl = gc_plist_hack ("conses-used", gc_count_num_cons_in_use, pl);
-#define PDUMP_HASHSIZE 200001
+ /* The things we do for backwards-compatibility */
+ return
+ list6 (Fcons (make_int (gc_count_num_cons_in_use),
+ make_int (gc_count_num_cons_freelist)),
+ Fcons (make_int (gc_count_num_symbol_in_use),
+ make_int (gc_count_num_symbol_freelist)),
+ Fcons (make_int (gc_count_num_marker_in_use),
+ make_int (gc_count_num_marker_freelist)),
+ make_int (gc_count_string_total_size),
+ make_int (gc_count_vector_total_size),
+ pl);
+}
+#undef HACK_O_MATIC
-static pdump_entry_list_elmt **pdump_hash;
+DEFUN ("consing-since-gc", Fconsing_since_gc, 0, 0, "", /*
+Return the number of bytes consed since the last garbage collection.
+\"Consed\" is a misnomer in that this actually counts allocation
+of all different kinds of objects, not just conses.
-/* Since most pointers are eight bytes aligned, the >>3 allows for a better hash */
-static int
-pdump_make_hash (const void *obj)
+If this value exceeds `gc-cons-threshold', a garbage collection happens.
+*/
+ ())
{
- return ((unsigned long)(obj)>>3) % PDUMP_HASHSIZE;
+ return make_int (consing_since_gc);
}
-static pdump_entry_list_elmt *
-pdump_get_entry (const void *obj)
+DEFUN ("memory-limit", Fmemory_limit, 0, 0, "", /*
+Return the address of the last byte Emacs has allocated, divided by 1024.
+This may be helpful in debugging Emacs's memory usage.
+The value is divided by 1024 to make sure it will fit in a lisp integer.
+*/
+ ())
{
- int pos = pdump_make_hash(obj);
- pdump_entry_list_elmt *e;
- while ((e = pdump_hash[pos]) != 0)
- {
- if (e->obj == obj)
- return e;
-
- pos++;
- if (pos == PDUMP_HASHSIZE)
- pos = 0;
- }
- return 0;
+ return make_int ((EMACS_INT) sbrk (0) / 1024);
}
-static void
-pdump_add_entry (pdump_entry_list *list, const void *obj, size_t size, int count, int is_lrecord)
-{
- pdump_entry_list_elmt *e;
- int align;
- int pos = pdump_make_hash (obj);
-
- while ((e = pdump_hash[pos]) != 0)
- {
- if (e->obj == obj)
- return;
-
- pos++;
- if (pos == PDUMP_HASHSIZE)
- pos = 0;
- }
-
- e = malloc (sizeof (pdump_entry_list_elmt));
-
- e->next = list->first;
- e->obj = obj;
- e->size = size;
- e->count = count;
- e->is_lrecord = is_lrecord;
- list->first = e;
-
- list->count += count;
- pdump_hash[pos] = e;
- align = align_table[size & 255];
- if (align<2 && is_lrecord)
- align = 2;
-
- if(align < list->align)
- list->align = align;
-}
-
-static pdump_entry_list *
-pdump_get_entry_list(const struct struct_description *sdesc)
+\f
+int
+object_dead_p (Lisp_Object obj)
{
- int i;
- for(i=0; i<pdump_struct_table.count; i++)
- if (pdump_struct_table.list[i].sdesc == sdesc)
- return &pdump_struct_table.list[i].list;
-
- if (pdump_struct_table.size <= pdump_struct_table.count)
- {
- if (pdump_struct_table.size == -1)
- pdump_struct_table.size = 10;
- else
- pdump_struct_table.size = pdump_struct_table.size * 2;
- pdump_struct_table.list = xrealloc (pdump_struct_table.list,
- pdump_struct_table.size*sizeof (pdump_struct_list_elmt));
- }
- pdump_struct_table.list[pdump_struct_table.count].list.first = 0;
- pdump_struct_table.list[pdump_struct_table.count].list.align = 8;
- pdump_struct_table.list[pdump_struct_table.count].list.count = 0;
- pdump_struct_table.list[pdump_struct_table.count].sdesc = sdesc;
-
- return &pdump_struct_table.list[pdump_struct_table.count++].list;
+ return ((BUFFERP (obj) && !BUFFER_LIVE_P (XBUFFER (obj))) ||
+ (FRAMEP (obj) && !FRAME_LIVE_P (XFRAME (obj))) ||
+ (WINDOWP (obj) && !WINDOW_LIVE_P (XWINDOW (obj))) ||
+ (DEVICEP (obj) && !DEVICE_LIVE_P (XDEVICE (obj))) ||
+ (CONSOLEP (obj) && !CONSOLE_LIVE_P (XCONSOLE (obj))) ||
+ (EVENTP (obj) && !EVENT_LIVE_P (XEVENT (obj))) ||
+ (EXTENTP (obj) && !EXTENT_LIVE_P (XEXTENT (obj))));
}
-static struct {
- Lisp_Object obj;
- int position;
- int offset;
-} backtrace[65536];
-
-static int depth;
+#ifdef MEMORY_USAGE_STATS
-static void pdump_backtrace (void)
-{
- int i;
- fprintf (stderr, "pdump backtrace :\n");
- for (i=0;i<depth;i++)
- {
- if (!backtrace[i].obj)
- fprintf (stderr, " - ind. (%d, %d)\n", backtrace[i].position, backtrace[i].offset);
- else
- {
- fprintf (stderr, " - %s (%d, %d)\n",
- XRECORD_LHEADER_IMPLEMENTATION (backtrace[i].obj)->name,
- backtrace[i].position,
- backtrace[i].offset);
- }
- }
-}
+/* Attempt to determine the actual amount of space that is used for
+ the block allocated starting at PTR, supposedly of size "CLAIMED_SIZE".
-static void pdump_register_object (Lisp_Object obj);
-static void pdump_register_struct (const void *data, const struct struct_description *sdesc, int count);
-
-static EMACS_INT
-pdump_get_indirect_count (EMACS_INT code, const struct lrecord_description *idesc, const void *idata)
-{
- EMACS_INT count;
- const void *irdata;
-
- int line = XD_INDIRECT_VAL (code);
- int delta = XD_INDIRECT_DELTA (code);
-
- irdata = ((char *)idata) + idesc[line].offset;
- switch (idesc[line].type) {
- case XD_SIZE_T:
- count = *(size_t *)irdata;
- break;
- case XD_INT:
- count = *(int *)irdata;
- break;
- case XD_LONG:
- count = *(long *)irdata;
- break;
- case XD_BYTECOUNT:
- count = *(Bytecount *)irdata;
- break;
- default:
- fprintf (stderr, "Unsupported count type : %d (line = %d, code=%ld)\n", idesc[line].type, line, (long)code);
- pdump_backtrace ();
- abort ();
- }
- count += delta;
- return count;
-}
+ It seems that the following holds:
-static void
-pdump_register_sub (const void *data, const struct lrecord_description *desc, int me)
-{
- int pos;
- const void *rdata;
+ 1. When using the old allocator (malloc.c):
- restart:
- for (pos = 0; desc[pos].type != XD_END; pos++)
- {
- backtrace[me].position = pos;
- backtrace[me].offset = desc[pos].offset;
+ -- blocks are always allocated in chunks of powers of two. For
+ each block, there is an overhead of 8 bytes if rcheck is not
+ defined, 20 bytes if it is defined. In other words, a
+ one-byte allocation needs 8 bytes of overhead for a total of
+ 9 bytes, and needs to have 16 bytes of memory chunked out for
+ it.
- rdata = ((const char *)data) + desc[pos].offset;
- switch(desc[pos].type)
- {
- case XD_SPECIFIER_END:
- pos = 0;
- desc = ((const struct Lisp_Specifier *)data)->methods->extra_description;
- goto restart;
- case XD_SIZE_T:
- case XD_INT:
- case XD_LONG:
- case XD_BYTECOUNT:
- case XD_LO_RESET_NIL:
- case XD_INT_RESET:
- case XD_LO_LINK:
- break;
- case XD_OPAQUE_DATA_PTR:
- {
- EMACS_INT count = desc[pos].data1;
- if (XD_IS_INDIRECT(count))
- count = pdump_get_indirect_count (count, desc, data);
-
- pdump_add_entry (&pdump_opaque_data_list,
- *(void **)rdata,
- count,
- 1,
- 0);
- break;
- }
- case XD_C_STRING:
- {
- const char *str = *(const char **)rdata;
- if (str)
- pdump_add_entry (&pdump_opaque_data_list, str, strlen (str)+1, 1, 0);
- break;
- }
- case XD_DOC_STRING:
- {
- const char *str = *(const char **)rdata;
- if ((EMACS_INT)str > 0)
- pdump_add_entry (&pdump_opaque_data_list, str, strlen (str)+1, 1, 0);
- break;
- }
- case XD_LISP_OBJECT:
- {
- EMACS_INT count = desc[pos].data1;
- int i;
- if (XD_IS_INDIRECT (count))
- count = pdump_get_indirect_count (count, desc, data);
-
- for(i=0;i<count;i++) {
- const Lisp_Object *pobj = ((const Lisp_Object *)rdata) + i;
- Lisp_Object dobj = *pobj;
-
- backtrace[me].offset = (const char *)pobj - (const char *)data;
- pdump_register_object (dobj);
- }
- break;
- }
- case XD_STRUCT_PTR:
- {
- EMACS_INT count = desc[pos].data1;
- const struct struct_description *sdesc = desc[pos].data2;
- const char *dobj = *(const char **)rdata;
- if (dobj) {
- if (XD_IS_INDIRECT (count))
- count = pdump_get_indirect_count (count, desc, data);
-
- pdump_register_struct (dobj, sdesc, count);
- }
- break;
- }
- default:
- fprintf (stderr, "Unsupported dump type : %d\n", desc[pos].type);
- pdump_backtrace ();
- abort ();
- };
- }
-}
+ 2. When using the new allocator (gmalloc.c):
-static void
-pdump_register_object (Lisp_Object obj)
-{
- if (!obj ||
- !POINTER_TYPE_P (XTYPE (obj)) ||
- pdump_get_entry (XRECORD_LHEADER (obj)))
- return;
-
- if (XRECORD_LHEADER_IMPLEMENTATION (obj)->description)
- {
- int me = depth++;
- if (me>65536)
- {
- fprintf (stderr, "Backtrace overflow, loop ?\n");
- abort ();
- }
- backtrace[me].obj = obj;
- backtrace[me].position = 0;
- backtrace[me].offset = 0;
-
- pdump_add_entry (pdump_object_table + XRECORD_LHEADER (obj)->type,
- XRECORD_LHEADER (obj),
- XRECORD_LHEADER_IMPLEMENTATION (obj)->static_size ?
- XRECORD_LHEADER_IMPLEMENTATION (obj)->static_size :
- XRECORD_LHEADER_IMPLEMENTATION (obj)->size_in_bytes_method (XRECORD_LHEADER (obj)),
- 1,
- 1);
- pdump_register_sub (XRECORD_LHEADER (obj),
- XRECORD_LHEADER_IMPLEMENTATION (obj)->description,
- me);
- --depth;
- }
- else
- {
- pdump_alert_undump_object[XRECORD_LHEADER (obj)->type]++;
- fprintf (stderr, "Undumpable object type : %s\n", XRECORD_LHEADER_IMPLEMENTATION (obj)->name);
- pdump_backtrace ();
- }
-}
+ -- blocks are always allocated in chunks of powers of two up
+ to 4096 bytes. Larger blocks are allocated in chunks of
+ an integral multiple of 4096 bytes. The minimum block
+ size is 2*sizeof (void *), or 16 bytes if SUNOS_LOCALTIME_BUG
+ is defined. There is no per-block overhead, but there
+ is an overhead of 3*sizeof (size_t) for each 4096 bytes
+ allocated.
-static void
-pdump_register_struct (const void *data, const struct struct_description *sdesc, int count)
-{
- if (data && !pdump_get_entry (data))
- {
- int me = depth++;
- int i;
- if (me>65536)
- {
- fprintf (stderr, "Backtrace overflow, loop ?\n");
- abort ();
- }
- backtrace[me].obj = 0;
- backtrace[me].position = 0;
- backtrace[me].offset = 0;
-
- pdump_add_entry (pdump_get_entry_list (sdesc),
- data,
- sdesc->size,
- count,
- 0);
- for (i=0; i<count; i++)
- {
- pdump_register_sub (((char *)data) + sdesc->size*i,
- sdesc->description,
- me);
- }
- --depth;
- }
-}
+ 3. When using the system malloc, anything goes, but they are
+ generally slower and more space-efficient than the GNU
+ allocators. One possibly reasonable assumption to make
+ for want of better data is that sizeof (void *), or maybe
+ 2 * sizeof (void *), is required as overhead and that
+ blocks are allocated in the minimum required size except
+ that some minimum block size is imposed (e.g. 16 bytes). */
-static void
-pdump_dump_data (pdump_entry_list_elmt *elmt, const struct lrecord_description *desc)
+size_t
+malloced_storage_size (void *ptr, size_t claimed_size,
+ struct overhead_stats *stats)
{
- size_t size = elmt->size;
- int count = elmt->count;
- if (desc)
- {
- int pos, i;
- void *rdata;
- memcpy (pdump_buf, elmt->obj, size*count);
-
- for (i=0; i<count; i++)
- {
- char *cur = ((char *)pdump_buf) + i*size;
- restart:
- for (pos = 0; desc[pos].type != XD_END; pos++)
- {
- rdata = cur + desc[pos].offset;
- switch (desc[pos].type)
- {
- case XD_SPECIFIER_END:
- pos = 0;
- desc = ((const struct Lisp_Specifier *)(elmt->obj))->methods->extra_description;
- goto restart;
- case XD_SIZE_T:
- case XD_INT:
- case XD_LONG:
- case XD_BYTECOUNT:
- break;
- case XD_LO_RESET_NIL:
- {
- EMACS_INT count = desc[pos].data1;
- int i;
- if (XD_IS_INDIRECT (count))
- count = pdump_get_indirect_count (count, desc, elmt->obj);
- for (i=0; i<count; i++)
- ((EMACS_INT *)rdata)[i] = pdump_qnil->save_offset;
- break;
- }
- case XD_INT_RESET:
- {
- EMACS_INT val = desc[pos].data1;
- if (XD_IS_INDIRECT (val))
- val = pdump_get_indirect_count (val, desc, elmt->obj);
- *(int *)rdata = val;
- break;
- }
- case XD_OPAQUE_DATA_PTR:
- case XD_C_STRING:
- case XD_STRUCT_PTR:
- {
- void *ptr = *(void **)rdata;
- if (ptr)
- *(EMACS_INT *)rdata = pdump_get_entry (ptr)->save_offset;
- break;
- }
- case XD_LO_LINK:
- {
- Lisp_Object obj = *(Lisp_Object *)rdata;
- pdump_entry_list_elmt *elmt1;
- for(;;)
- {
- elmt1 = pdump_get_entry (XRECORD_LHEADER(obj));
- if (elmt1)
- break;
- obj = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj)));
- }
- *(EMACS_INT *)rdata = elmt1->save_offset;
- break;
- }
- case XD_LISP_OBJECT:
- {
- EMACS_INT count = desc[pos].data1;
- int i;
- if (XD_IS_INDIRECT (count))
- count = pdump_get_indirect_count (count, desc, elmt->obj);
-
- for(i=0; i<count; i++)
- {
- Lisp_Object *pobj = ((Lisp_Object *)rdata) + i;
- Lisp_Object dobj = *pobj;
- if (dobj && POINTER_TYPE_P (XTYPE (dobj)))
- *pobj = pdump_get_entry (XRECORD_LHEADER (dobj))->save_offset;
- }
- break;
- }
- case XD_DOC_STRING:
- {
- EMACS_INT str = *(EMACS_INT *)rdata;
- if (str > 0)
- *(EMACS_INT *)rdata = pdump_get_entry ((void *)str)->save_offset;
- break;
- }
- default:
- fprintf (stderr, "Unsupported dump type : %d\n", desc[pos].type);
- abort ();
- };
- }
- }
- }
- write (pdump_fd, desc ? pdump_buf : elmt->obj, size*count);
- if (elmt->is_lrecord && ((size*count) & 3))
- write (pdump_fd, "\0\0\0", 4-((size*count) & 3));
-}
+ size_t orig_claimed_size = claimed_size;
-static void
-pdump_reloc_one (void *data, EMACS_INT delta, const struct lrecord_description *desc)
-{
- int pos;
- void *rdata;
+#ifdef GNU_MALLOC
- restart:
- for (pos = 0; desc[pos].type != XD_END; pos++)
+ if (claimed_size < 2 * sizeof (void *))
+ claimed_size = 2 * sizeof (void *);
+# ifdef SUNOS_LOCALTIME_BUG
+ if (claimed_size < 16)
+ claimed_size = 16;
+# endif
+ if (claimed_size < 4096)
{
- rdata = ((char *)data) + desc[pos].offset;
- switch (desc[pos].type) {
- case XD_SPECIFIER_END:
- pos = 0;
- desc = ((const struct Lisp_Specifier *)data)->methods->extra_description;
- goto restart;
- case XD_SIZE_T:
- case XD_INT:
- case XD_LONG:
- case XD_BYTECOUNT:
- case XD_INT_RESET:
- break;
- case XD_OPAQUE_DATA_PTR:
- case XD_C_STRING:
- case XD_STRUCT_PTR:
- case XD_LO_LINK:
- {
- EMACS_INT ptr = *(EMACS_INT *)rdata;
- if (ptr)
- *(EMACS_INT *)rdata = ptr+delta;
- break;
- }
- case XD_LISP_OBJECT:
- case XD_LO_RESET_NIL:
- {
- EMACS_INT count = desc[pos].data1;
- int i;
- if (XD_IS_INDIRECT (count))
- count = pdump_get_indirect_count (count, desc, data);
-
- for (i=0; i<count; i++)
- {
- Lisp_Object *pobj = ((Lisp_Object *)rdata) + i;
- Lisp_Object dobj = *pobj;
- if (dobj && POINTER_TYPE_P (XTYPE (dobj)))
- *pobj = dobj + delta;
- }
- break;
- }
- case XD_DOC_STRING:
- {
- EMACS_INT str = *(EMACS_INT *)rdata;
- if (str > 0)
- *(EMACS_INT *)rdata = str + delta;
- break;
- }
- default:
- fprintf (stderr, "Unsupported dump type : %d\n", desc[pos].type);
- abort ();
- };
- }
-}
-
-static void
-pdump_allocate_offset (pdump_entry_list_elmt *elmt, const struct lrecord_description *desc)
-{
- size_t size = (elmt->is_lrecord ? (elmt->size + 3) & ~3 : elmt->size)*elmt->count;
- elmt->save_offset = cur_offset;
- if (size>max_size)
- max_size = size;
- cur_offset += size;
-}
+ int log = 1;
-static void
-pdump_scan_by_alignement (void (*f)(pdump_entry_list_elmt *, const struct lrecord_description *))
-{
- int align, i;
- const struct lrecord_description *idesc;
- pdump_entry_list_elmt *elmt;
- for (align=8; align>=0; align--)
- {
- for (i=0; i<=last_lrecord_type_index_assigned; i++)
- if (pdump_object_table[i].align == align)
- {
- elmt = pdump_object_table[i].first;
- if (!elmt)
- continue;
- idesc = lrecord_implementations_table[i]->description;
- while (elmt)
- {
- f (elmt, idesc);
- elmt = elmt->next;
- }
- }
-
- for (i=0; i<pdump_struct_table.count; i++)
- if (pdump_struct_table.list[i].list.align == align) {
- elmt = pdump_struct_table.list[i].list.first;
- idesc = pdump_struct_table.list[i].sdesc->description;
- while (elmt)
- {
- f (elmt, idesc);
- elmt = elmt->next;
- }
- }
-
- elmt = pdump_opaque_data_list.first;
- while (elmt)
- {
- if (align_table[elmt->size & 255] == align)
- f (elmt, 0);
- elmt = elmt->next;
- }
+ /* compute the log base two, more or less, then use it to compute
+ the block size needed. */
+ claimed_size--;
+ /* It's big, it's heavy, it's wood! */
+ while ((claimed_size /= 2) != 0)
+ ++log;
+ claimed_size = 1;
+ /* It's better than bad, it's good! */
+ while (log > 0)
+ {
+ claimed_size *= 2;
+ log--;
+ }
+ /* We have to come up with some average about the amount of
+ blocks used. */
+ if ((size_t) (rand () & 4095) < claimed_size)
+ claimed_size += 3 * sizeof (void *);
}
-}
-
-static void
-pdump_dump_staticvec (void)
-{
- Lisp_Object *reloc = malloc (staticidx*sizeof (Lisp_Object));
- int i;
- write (pdump_fd, staticvec, staticidx*sizeof (Lisp_Object *));
-
- for(i=0; i<staticidx; i++)
+ else
{
- Lisp_Object obj = *staticvec[i];
- if (obj && POINTER_TYPE_P (XTYPE (obj)))
- reloc[i] = pdump_get_entry (XRECORD_LHEADER (obj))->save_offset;
- else
- reloc[i] = obj;
+ claimed_size += 4095;
+ claimed_size &= ~4095;
+ claimed_size += (claimed_size / 4096) * 3 * sizeof (size_t);
}
- write (pdump_fd, reloc, staticidx*sizeof (Lisp_Object));
- free (reloc);
-}
-static void
-pdump_dump_structvec (void)
-{
- int i;
- for (i=0; i<dumpstructidx; i++)
- {
- EMACS_INT adr;
- write (pdump_fd, &(dumpstructvec[i].data), sizeof (void *));
- adr = pdump_get_entry (*(void **)(dumpstructvec[i].data))->save_offset;
- write (pdump_fd, &adr, sizeof (adr));
- }
-}
+#elif defined (SYSTEM_MALLOC)
-static void
-pdump_dump_itable (void)
-{
- write (pdump_fd, lrecord_implementations_table, sizeof (lrecord_implementations_table));
-}
+ if (claimed_size < 16)
+ claimed_size = 16;
+ claimed_size += 2 * sizeof (void *);
-static void
-pdump_dump_rtables (void)
-{
- int i, j;
- pdump_entry_list_elmt *elmt;
- pdump_reloc_table rt;
+#else /* old GNU allocator */
- for (i=0; i<=last_lrecord_type_index_assigned; i++)
- {
- elmt = pdump_object_table[i].first;
- if(!elmt)
- continue;
- rt.desc = lrecord_implementations_table[i]->description;
- rt.count = pdump_object_table[i].count;
- write (pdump_fd, &rt, sizeof (rt));
- while (elmt)
- {
- EMACS_INT rdata = pdump_get_entry (XRECORD_LHEADER (elmt->obj))->save_offset;
- write (pdump_fd, &rdata, sizeof (rdata));
- elmt = elmt->next;
- }
+# ifdef rcheck /* #### may not be defined here */
+ claimed_size += 20;
+# else
+ claimed_size += 8;
+# endif
+ {
+ int log = 1;
+
+ /* compute the log base two, more or less, then use it to compute
+ the block size needed. */
+ claimed_size--;
+ /* It's big, it's heavy, it's wood! */
+ while ((claimed_size /= 2) != 0)
+ ++log;
+ claimed_size = 1;
+ /* It's better than bad, it's good! */
+ while (log > 0)
+ {
+ claimed_size *= 2;
+ log--;
+ }
}
- rt.desc = 0;
- rt.count = 0;
- write (pdump_fd, &rt, sizeof (rt));
+#endif /* old GNU allocator */
- for (i=0; i<pdump_struct_table.count; i++)
+ if (stats)
{
- elmt = pdump_struct_table.list[i].list.first;
- rt.desc = pdump_struct_table.list[i].sdesc->description;
- rt.count = pdump_struct_table.list[i].list.count;
- write (pdump_fd, &rt, sizeof (rt));
- while (elmt)
- {
- EMACS_INT rdata = pdump_get_entry (XRECORD_LHEADER (elmt->obj))->save_offset;
- for (j=0; j<elmt->count; j++) {
- write (pdump_fd, &rdata, sizeof (rdata));
- rdata += elmt->size;
- }
- elmt = elmt->next;
- }
+ stats->was_requested += orig_claimed_size;
+ stats->malloc_overhead += claimed_size - orig_claimed_size;
}
- rt.desc = 0;
- rt.count = 0;
- write (pdump_fd, &rt, sizeof (rt));
+ return claimed_size;
}
-static void
-pdump_dump_wired (void)
+size_t
+fixed_type_block_overhead (size_t size)
{
- EMACS_INT count = pdump_wireidx + pdump_wireidx_list;
- int i;
-
- write (pdump_fd, &count, sizeof (count));
-
- for (i=0; i<pdump_wireidx; i++)
- {
- Lisp_Object obj = pdump_get_entry (XRECORD_LHEADER (*(pdump_wirevec[i])))->save_offset;
- write (pdump_fd, &pdump_wirevec[i], sizeof (pdump_wirevec[i]));
- write (pdump_fd, &obj, sizeof (obj));
- }
-
- for (i=0; i<pdump_wireidx_list; i++)
+ size_t per_block = TYPE_ALLOC_SIZE (cons, unsigned char);
+ size_t overhead = 0;
+ size_t storage_size = malloced_storage_size (0, per_block, 0);
+ while (size >= per_block)
{
- Lisp_Object obj = *(pdump_wirevec_list[i]);
- pdump_entry_list_elmt *elmt;
- EMACS_INT res;
-
- for(;;)
- {
- const struct lrecord_description *desc;
- int pos;
- elmt = pdump_get_entry (XRECORD_LHEADER (obj));
- if (elmt)
- break;
- desc = XRECORD_LHEADER_IMPLEMENTATION (obj)->description;
- for (pos = 0; desc[pos].type != XD_LO_LINK; pos++)
- if (desc[pos].type == XD_END)
- abort ();
-
- obj = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj)));
- }
- res = elmt->save_offset;
-
- write (pdump_fd, &pdump_wirevec_list[i], sizeof (pdump_wirevec_list[i]));
- write (pdump_fd, &res, sizeof (res));
+ size -= per_block;
+ overhead += sizeof (void *) + per_block - storage_size;
}
+ if (rand () % per_block < size)
+ overhead += sizeof (void *) + per_block - storage_size;
+ return overhead;
}
+#endif /* MEMORY_USAGE_STATS */
+
+\f
+/* Initialization */
void
-pdump (void)
+init_alloc_once_early (void)
{
- int i;
- Lisp_Object t_console, t_device, t_frame;
- int none;
- dump_header hd;
-
- /* These appear in a DEFVAR_LISP, which does a staticpro() */
- t_console = Vterminal_console;
- t_frame = Vterminal_frame;
- t_device = Vterminal_device;
-
- Vterminal_console = Qnil;
- Vterminal_frame = Qnil;
- Vterminal_device = Qnil;
-
- pdump_hash = malloc (PDUMP_HASHSIZE*sizeof (pdump_entry_list_elmt *));
- memset (pdump_hash, 0, PDUMP_HASHSIZE*sizeof (pdump_entry_list_elmt *));
+ int iii;
- for (i=0; i<=last_lrecord_type_index_assigned; i++)
+#ifdef PURESTAT
+ for (iii = 0; iii < countof (purestats); iii++)
{
- pdump_object_table[i].first = 0;
- pdump_object_table[i].align = 8;
- pdump_object_table[i].count = 0;
- pdump_alert_undump_object[i] = 0;
+ if (! purestats[iii]) continue;
+ purestats[iii]->nobjects = 0;
+ purestats[iii]->nbytes = 0;
}
- pdump_struct_table.count = 0;
- pdump_struct_table.size = -1;
-
- pdump_opaque_data_list.first = 0;
- pdump_opaque_data_list.align = 8;
- pdump_opaque_data_list.count = 0;
- depth = 0;
-
- for (i=0; i<staticidx; i++)
- pdump_register_object (*staticvec[i]);
- for (i=0; i<pdump_wireidx; i++)
- pdump_register_object (*pdump_wirevec[i]);
-
- none = 1;
- for(i=0;i<=last_lrecord_type_index_assigned;i++)
- if (pdump_alert_undump_object[i])
- {
- if (none)
- printf ("Undumpable types list :\n");
- none = 0;
- printf (" - %s (%d)\n", lrecord_implementations_table[i]->name, pdump_alert_undump_object[i]);
- }
- if (!none)
- return;
-
- for (i=0; i<dumpstructidx; i++)
- pdump_register_struct (*(void **)(dumpstructvec[i].data), dumpstructvec[i].desc, 1);
-
- memcpy (hd.signature, "XEmacsDP", 8);
- hd.reloc_address = 0;
- hd.nb_staticpro = staticidx;
- hd.nb_structdmp = dumpstructidx;
- hd.last_type = last_lrecord_type_index_assigned;
-
- cur_offset = 256;
- max_size = 0;
-
- pdump_scan_by_alignement (pdump_allocate_offset);
- pdump_qnil = pdump_get_entry (XRECORD_LHEADER (Qnil));
-
- pdump_buf = malloc (max_size);
- pdump_fd = open ("xemacs.dmp", O_WRONLY|O_CREAT|O_TRUNC, 0666);
- hd.stab_offset = (cur_offset + 3) & ~3;
+ purecopying_for_bytecode = 0;
+#endif /* PURESTAT */
- write (pdump_fd, &hd, sizeof (hd));
- lseek (pdump_fd, 256, SEEK_SET);
+ last_lrecord_type_index_assigned = -1;
+ for (iii = 0; iii < countof (lrecord_implementations_table); iii++)
+ {
+ lrecord_implementations_table[iii] = 0;
+ }
- pdump_scan_by_alignement (pdump_dump_data);
+#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
+ /*
+ * If USE_INDEXED_LRECORD_IMPLEMENTATION is defined, all the staticly
+ * defined subr lrecords were initialized with lheader->type == 0.
+ * See subr_lheader_initializer in lisp.h. Force type index 0 to be
+ * assigned to lrecord_subr so that those predefined indexes match
+ * reality.
+ */
+ lrecord_type_index (lrecord_subr);
+ assert (*(lrecord_subr[0].lrecord_type_index) == 0);
+ /*
+ * The same is true for symbol_value_forward objects, except the
+ * type is 1.
+ */
+ lrecord_type_index (lrecord_symbol_value_forward);
+ assert (*(lrecord_symbol_value_forward[0].lrecord_type_index) == 1);
+#endif /* USE_INDEXED_LRECORD_IMPLEMENTATION */
- lseek (pdump_fd, hd.stab_offset, SEEK_SET);
+ symbols_initialized = 0;
- pdump_dump_staticvec ();
- pdump_dump_structvec ();
- pdump_dump_itable ();
- pdump_dump_rtables ();
- pdump_dump_wired ();
+ gc_generation_number[0] = 0;
+ /* purify_flag 1 is correct even if CANNOT_DUMP.
+ * loadup.el will set to nil at end. */
+ purify_flag = 1;
+ pure_bytes_used = 0;
+ pure_lossage = 0;
+ breathing_space = 0;
+#ifndef LRECORD_VECTOR
+ XSETINT (all_vectors, 0); /* Qzero may not be set yet. */
+#endif
+ XSETINT (all_bit_vectors, 0); /* Qzero may not be set yet. */
+ XSETINT (Vgc_message, 0);
+ all_lcrecords = 0;
+ ignore_malloc_warnings = 1;
+#ifdef DOUG_LEA_MALLOC
+ mallopt (M_TRIM_THRESHOLD, 128*1024); /* trim threshold */
+ mallopt (M_MMAP_THRESHOLD, 64*1024); /* mmap threshold */
+#if 0 /* Moved to emacs.c */
+ mallopt (M_MMAP_MAX, 64); /* max. number of mmap'ed areas */
+#endif
+#endif
+ init_string_alloc ();
+ init_string_chars_alloc ();
+ init_cons_alloc ();
+ init_symbol_alloc ();
+ init_compiled_function_alloc ();
+#ifdef LISP_FLOAT_TYPE
+ init_float_alloc ();
+#endif /* LISP_FLOAT_TYPE */
+ init_marker_alloc ();
+ init_extent_alloc ();
+ init_event_alloc ();
- close (pdump_fd);
- free (pdump_buf);
+ ignore_malloc_warnings = 0;
+ staticidx = 0;
+ consing_since_gc = 0;
+#if 1
+ gc_cons_threshold = 500000; /* XEmacs change */
+#else
+ gc_cons_threshold = 15000; /* debugging */
+#endif
+#ifdef VIRT_ADDR_VARIES
+ malloc_sbrk_unused = 1<<22; /* A large number */
+ malloc_sbrk_used = 100000; /* as reasonable as any number */
+#endif /* VIRT_ADDR_VARIES */
+ lrecord_uid_counter = 259;
+ debug_string_purity = 0;
+ gcprolist = 0;
- free (pdump_hash);
+ gc_currently_forbidden = 0;
+ gc_hooks_inhibited = 0;
- Vterminal_console = t_console;
- Vterminal_frame = t_frame;
- Vterminal_device = t_device;
+#ifdef ERROR_CHECK_TYPECHECK
+ ERROR_ME.really_unlikely_name_to_have_accidentally_in_a_non_errb_structure =
+ 666;
+ ERROR_ME_NOT.
+ really_unlikely_name_to_have_accidentally_in_a_non_errb_structure = 42;
+ ERROR_ME_WARN.
+ really_unlikely_name_to_have_accidentally_in_a_non_errb_structure =
+ 3333632;
+#endif /* ERROR_CHECK_TYPECHECK */
}
-int
-pdump_load (void)
+void
+reinit_alloc (void)
{
- size_t length;
- int i;
- char *p;
- EMACS_INT delta;
- EMACS_INT count;
-
- pdump_start = pdump_end = 0;
-
- pdump_fd = open ("xemacs.dmp", O_RDONLY);
- if (pdump_fd<0)
- return 0;
+ gcprolist = 0;
+}
- length = lseek (pdump_fd, 0, SEEK_END);
- lseek (pdump_fd, 0, SEEK_SET);
+void
+syms_of_alloc (void)
+{
+ defsymbol (&Qpre_gc_hook, "pre-gc-hook");
+ defsymbol (&Qpost_gc_hook, "post-gc-hook");
+ defsymbol (&Qgarbage_collecting, "garbage-collecting");
-#ifdef HAVE_MMAP
- pdump_start = mmap (0, length, PROT_READ|PROT_WRITE, MAP_PRIVATE, pdump_fd, 0);
- if (pdump_start == MAP_FAILED)
- pdump_start = 0;
-#endif
-
- if (!pdump_start)
- {
- pdump_start = (void *)((((unsigned long)(malloc(length+255))) + 255) & ~255);
- read(pdump_fd, pdump_start, length);
- }
+ DEFSUBR (Fcons);
+ DEFSUBR (Flist);
+ DEFSUBR (Fvector);
+ DEFSUBR (Fbit_vector);
+ DEFSUBR (Fmake_byte_code);
+ DEFSUBR (Fmake_list);
+ DEFSUBR (Fmake_vector);
+ DEFSUBR (Fmake_bit_vector);
+ DEFSUBR (Fmake_string);
+ DEFSUBR (Fstring);
+ DEFSUBR (Fmake_symbol);
+ DEFSUBR (Fmake_marker);
+ DEFSUBR (Fpurecopy);
+ DEFSUBR (Fgarbage_collect);
+ DEFSUBR (Fmemory_limit);
+ DEFSUBR (Fconsing_since_gc);
+}
- close (pdump_fd);
+void
+vars_of_alloc (void)
+{
+ DEFVAR_INT ("gc-cons-threshold", &gc_cons_threshold /*
+*Number of bytes of consing between garbage collections.
+\"Consing\" is a misnomer in that this actually counts allocation
+of all different kinds of objects, not just conses.
+Garbage collection can happen automatically once this many bytes have been
+allocated since the last garbage collection. All data types count.
- pdump_end = pdump_start + length;
+Garbage collection happens automatically when `eval' or `funcall' are
+called. (Note that `funcall' is called implicitly as part of evaluation.)
+By binding this temporarily to a large number, you can effectively
+prevent garbage collection during a part of the program.
- staticidx = ((dump_header *)(pdump_start))->nb_staticpro;
- last_lrecord_type_index_assigned = ((dump_header *)(pdump_start))->last_type;
- delta = ((EMACS_INT)pdump_start) - ((dump_header *)pdump_start)->reloc_address;
- p = pdump_start + ((dump_header *)pdump_start)->stab_offset;
+See also `consing-since-gc'.
+*/ );
- /* Put back the staticvec in place */
- memcpy (staticvec, p, staticidx*sizeof (Lisp_Object *));
- p += staticidx*sizeof (Lisp_Object *);
- for (i=0; i<staticidx; i++)
- {
- Lisp_Object obj = *(Lisp_Object *)p;
- p += sizeof (Lisp_Object);
- if (obj && POINTER_TYPE_P (XTYPE (obj)))
- obj += delta;
- *staticvec[i] = obj;
- }
+ DEFVAR_INT ("pure-bytes-used", &pure_bytes_used /*
+Number of bytes of sharable Lisp data allocated so far.
+*/ );
- /* Put back the dumpstructs */
- for (i=0; i<((dump_header *)pdump_start)->nb_structdmp; i++)
- {
- void **adr = *(void **)p;
- p += sizeof (void *);
- *adr = (void *)((*(EMACS_INT *)p) + delta);
- p += sizeof (EMACS_INT);
- }
+#if 0
+ DEFVAR_INT ("data-bytes-used", &malloc_sbrk_used /*
+Number of bytes of unshared memory allocated in this session.
+*/ );
- /* Put back the lrecord_implementations_table */
- memcpy (lrecord_implementations_table, p, sizeof (lrecord_implementations_table));
- p += sizeof (lrecord_implementations_table);
+ DEFVAR_INT ("data-bytes-free", &malloc_sbrk_unused /*
+Number of bytes of unshared memory remaining available in this session.
+*/ );
+#endif
- /* Give back their numbers to the lrecord implementations */
- for (i=0; i<sizeof(lrecord_implementations_table)/sizeof(lrecord_implementations_table[0]); i++)
- if (lrecord_implementations_table[i])
- {
- *(lrecord_implementations_table[i]->lrecord_type_index) = i;
- last_lrecord_type_index_assigned = i;
- }
+#ifdef DEBUG_XEMACS
+ DEFVAR_INT ("debug-allocation", &debug_allocation /*
+If non-zero, print out information to stderr about all objects allocated.
+See also `debug-allocation-backtrace-length'.
+*/ );
+ debug_allocation = 0;
- /* Do the relocations */
- pdump_rt_list = p;
- count = 2;
- for(;;)
- {
- pdump_reloc_table *rt = (pdump_reloc_table *)p;
- p += sizeof (pdump_reloc_table);
- if (rt->desc) {
- for (i=0; i<rt->count; i++)
- {
- EMACS_INT adr = delta + *(EMACS_INT *)p;
- *(EMACS_INT *)p = adr;
- pdump_reloc_one ((void *)adr, delta, rt->desc);
- p += sizeof (EMACS_INT);
- }
- } else
- if(!(--count))
- break;
- }
+ DEFVAR_INT ("debug-allocation-backtrace-length",
+ &debug_allocation_backtrace_length /*
+Length (in stack frames) of short backtrace printed out by `debug-allocation'.
+*/ );
+ debug_allocation_backtrace_length = 2;
+#endif
- /* Put the pdump_wire variables in place */
- count = *(EMACS_INT *)p;
- p += sizeof(EMACS_INT);
+ DEFVAR_BOOL ("purify-flag", &purify_flag /*
+Non-nil means loading Lisp code in order to dump an executable.
+This means that certain objects should be allocated in shared (pure) space.
+*/ );
- for (i=0; i<count; i++)
- {
- Lisp_Object *var, obj;
- var = *(Lisp_Object **)p;
- p += sizeof (Lisp_Object *);
+ DEFVAR_LISP ("pre-gc-hook", &Vpre_gc_hook /*
+Function or functions to be run just before each garbage collection.
+Interrupts, garbage collection, and errors are inhibited while this hook
+runs, so be extremely careful in what you add here. In particular, avoid
+consing, and do not interact with the user.
+*/ );
+ Vpre_gc_hook = Qnil;
- obj = *(Lisp_Object *)p;
- p += sizeof (Lisp_Object);
+ DEFVAR_LISP ("post-gc-hook", &Vpost_gc_hook /*
+Function or functions to be run just after each garbage collection.
+Interrupts, garbage collection, and errors are inhibited while this hook
+runs, so be extremely careful in what you add here. In particular, avoid
+consing, and do not interact with the user.
+*/ );
+ Vpost_gc_hook = Qnil;
- if (obj && POINTER_TYPE_P (XTYPE (obj)))
- obj += delta;
- *var = obj;
- }
+ DEFVAR_LISP ("gc-message", &Vgc_message /*
+String to print to indicate that a garbage collection is in progress.
+This is printed in the echo area. If the selected frame is on a
+window system and `gc-pointer-glyph' specifies a value (i.e. a pointer
+image instance) in the domain of the selected frame, the mouse pointer
+will change instead of this message being printed.
+*/ );
+ Vgc_message = make_pure_string ((CONST Bufbyte *) gc_default_message,
+ countof (gc_default_message) - 1,
+ Qnil, 1);
- /* Final cleanups */
- /* reorganize hash tables */
- p = pdump_rt_list;
- for(;;)
- {
- pdump_reloc_table *rt = (pdump_reloc_table *)p;
- p += sizeof (pdump_reloc_table);
- if (!rt->desc)
- break;
- if (rt->desc == hash_table_description)
- {
- for (i=0; i<rt->count; i++)
- {
- struct Lisp_Hash_Table *ht = XHASH_TABLE (*(EMACS_INT *)p);
- reorganize_hash_table (ht);
- p += sizeof (EMACS_INT);
- }
- break;
- } else
- p += sizeof (EMACS_INT)*rt->count;
- }
- return 1;
+ DEFVAR_LISP ("gc-pointer-glyph", &Vgc_pointer_glyph /*
+Pointer glyph used to indicate that a garbage collection is in progress.
+If the selected window is on a window system and this glyph specifies a
+value (i.e. a pointer image instance) in the domain of the selected
+window, the pointer will be changed as specified during garbage collection.
+Otherwise, a message will be printed in the echo area, as controlled
+by `gc-message'.
+*/ );
}
-#endif
+void
+complex_vars_of_alloc (void)
+{
+ Vgc_pointer_glyph = Fmake_glyph_internal (Qpointer);
+}
projects / chise / xemacs-chise.git.1 / blobdiff