1 /* Storage allocation and gc for GNU Emacs Lisp interpreter.
3 Copyright (C) 1985-1986, 1988, 1993-1995, 1997-2014 Free Software
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
25 #ifdef ENABLE_CHECKING
26 #include <signal.h> /* For SIGABRT. */
37 #include "intervals.h"
38 #include "character.h"
43 #include "termhooks.h" /* For struct terminal. */
44 #ifdef HAVE_WINDOW_SYSTEM
46 #endif /* HAVE_WINDOW_SYSTEM */
49 #include <execinfo.h> /* For backtrace. */
51 #if (defined ENABLE_CHECKING \
52 && defined HAVE_VALGRIND_VALGRIND_H \
53 && !defined USE_VALGRIND)
54 # define USE_VALGRIND 1
58 #include <valgrind/valgrind.h>
59 #include <valgrind/memcheck.h>
60 static bool valgrind_p
;
71 #include "w32heap.h" /* for sbrk */
74 /* Default value of gc_cons_threshold (see below). */
76 #define GC_DEFAULT_THRESHOLD (100000 * word_size)
78 /* Global variables. */
79 struct emacs_globals globals
;
81 /* Number of bytes of consing done since the last gc. */
83 EMACS_INT consing_since_gc
;
85 /* Similar minimum, computed from Vgc_cons_percentage. */
87 EMACS_INT gc_relative_threshold
;
89 /* Minimum number of bytes of consing since GC before next GC,
90 when memory is full. */
92 EMACS_INT memory_full_cons_threshold
= 1 << 10;
98 /* True means abort if try to GC.
99 This is for code which is written on the assumption that
100 no GC will happen, so as to verify that assumption. */
104 /* Number of live and free conses etc. */
106 static EMACS_INT total_conses
, total_markers
, total_symbols
, total_buffers
;
107 static EMACS_INT total_free_conses
, total_free_markers
, total_free_symbols
;
108 static EMACS_INT total_free_floats
, total_floats
;
110 /* Points to memory space allocated as "spare", to be freed if we run
113 static void *spare_memory
;
115 /* Amount of spare memory to keep in large reserve block, or to see
116 whether this much is available when malloc fails on a larger request. */
118 #define SPARE_MEMORY (1 << 15)
120 /* If nonzero, this is a warning delivered by malloc and not yet
123 const char *pending_malloc_warning
;
125 static Lisp_Object Qgc_cons_threshold
;
126 Lisp_Object Qchar_table_extra_slots
;
128 /* Hook run after GC has finished. */
130 static Lisp_Object Qpost_gc_hook
;
132 #if !defined REL_ALLOC || defined SYSTEM_MALLOC
133 static void refill_memory_reserve (void);
135 static Lisp_Object
make_empty_string (int);
136 extern Lisp_Object
which_symbols (Lisp_Object
, EMACS_INT
) EXTERNALLY_VISIBLE
;
142 /* Recording what needs to be marked for gc. */
144 struct gcpro
*gcprolist
;
146 /************************************************************************
148 ************************************************************************/
150 /* Function malloc calls this if it finds we are near exhausting storage. */
153 malloc_warning (const char *str
)
155 pending_malloc_warning
= str
;
159 /* Display an already-pending malloc warning. */
162 display_malloc_warning (void)
164 call3 (intern ("display-warning"),
166 build_string (pending_malloc_warning
),
167 intern ("emergency"));
168 pending_malloc_warning
= 0;
171 /* Called if we can't allocate relocatable space for a buffer. */
174 buffer_memory_full (ptrdiff_t nbytes
)
176 /* If buffers use the relocating allocator, no need to free
177 spare_memory, because we may have plenty of malloc space left
178 that we could get, and if we don't, the malloc that fails will
179 itself cause spare_memory to be freed. If buffers don't use the
180 relocating allocator, treat this like any other failing
184 memory_full (nbytes
);
186 /* This used to call error, but if we've run out of memory, we could
187 get infinite recursion trying to build the string. */
188 xsignal (Qnil
, Vmemory_signal_data
);
192 /* Like GC_MALLOC but check for no memory. */
195 xmalloc (size_t size
)
197 void *val
= GC_MALLOC (size
);
203 /* Like the above, but zeroes out the memory just allocated. */
206 xzalloc (size_t size
)
208 return xmalloc (size
);
211 /* Like GC_REALLOC but check for no memory. */
214 xrealloc (void *block
, size_t size
)
216 void *val
= GC_REALLOC (block
, size
);
228 /* Allocate pointerless memory. */
231 xmalloc_atomic (size_t size
)
233 void *val
= GC_MALLOC_ATOMIC (size
);
240 xzalloc_atomic (size_t size
)
242 return xmalloc_atomic (size
);
245 /* Allocate uncollectable memory. */
248 xmalloc_uncollectable (size_t size
)
250 void *val
= GC_MALLOC_UNCOLLECTABLE (size
);
256 /* Allocate memory, but if memory is exhausted, return NULL instead of
257 signalling an error. */
260 xmalloc_unsafe (size_t size
)
262 return GC_MALLOC (size
);
265 /* Allocate pointerless memory, but if memory is exhausted, return
266 NULL instead of signalling an error. */
269 xmalloc_atomic_unsafe (size_t size
)
271 return GC_MALLOC_ATOMIC (size
);
274 /* Other parts of Emacs pass large int values to allocator functions
275 expecting ptrdiff_t. This is portable in practice, but check it to
277 verify (INT_MAX
<= PTRDIFF_MAX
);
280 /* Allocate an array of NITEMS items, each of size ITEM_SIZE.
281 Signal an error on memory exhaustion. */
284 xnmalloc (ptrdiff_t nitems
, ptrdiff_t item_size
)
286 eassert (0 <= nitems
&& 0 < item_size
);
287 if (min (PTRDIFF_MAX
, SIZE_MAX
) / item_size
< nitems
)
288 memory_full (SIZE_MAX
);
289 return xmalloc (nitems
* item_size
);
292 /* Like xnmalloc for pointerless objects. */
295 xnmalloc_atomic (ptrdiff_t nitems
, ptrdiff_t item_size
)
297 eassert (0 <= nitems
&& 0 < item_size
);
298 if (min (PTRDIFF_MAX
, SIZE_MAX
) / item_size
< nitems
)
299 memory_full (SIZE_MAX
);
300 return xmalloc_atomic (nitems
* item_size
);
303 /* Reallocate an array PA to make it of NITEMS items, each of size ITEM_SIZE.
304 Signal an error on memory exhaustion. */
307 xnrealloc (void *pa
, ptrdiff_t nitems
, ptrdiff_t item_size
)
309 eassert (0 <= nitems
&& 0 < item_size
);
310 if (min (PTRDIFF_MAX
, SIZE_MAX
) / item_size
< nitems
)
311 memory_full (SIZE_MAX
);
312 return xrealloc (pa
, nitems
* item_size
);
316 /* Grow PA, which points to an array of *NITEMS items, and return the
317 location of the reallocated array, updating *NITEMS to reflect its
318 new size. The new array will contain at least NITEMS_INCR_MIN more
319 items, but will not contain more than NITEMS_MAX items total.
320 ITEM_SIZE is the size of each item, in bytes.
322 ITEM_SIZE and NITEMS_INCR_MIN must be positive. *NITEMS must be
323 nonnegative. If NITEMS_MAX is -1, it is treated as if it were
326 If PA is null, then allocate a new array instead of reallocating
329 If memory exhaustion occurs, set *NITEMS to zero if PA is null, and
330 signal an error (i.e., do not return).
332 Thus, to grow an array A without saving its old contents, do
333 { xfree (A); A = NULL; A = xpalloc (NULL, &AITEMS, ...); }.
334 The A = NULL avoids a dangling pointer if xpalloc exhausts memory
335 and signals an error, and later this code is reexecuted and
336 attempts to free A. */
339 xpalloc (void *pa
, ptrdiff_t *nitems
, ptrdiff_t nitems_incr_min
,
340 ptrdiff_t nitems_max
, ptrdiff_t item_size
)
342 /* The approximate size to use for initial small allocation
343 requests. This is the largest "small" request for the GNU C
345 enum { DEFAULT_MXFAST
= 64 * sizeof (size_t) / 4 };
347 /* If the array is tiny, grow it to about (but no greater than)
348 DEFAULT_MXFAST bytes. Otherwise, grow it by about 50%. */
349 ptrdiff_t n
= *nitems
;
350 ptrdiff_t tiny_max
= DEFAULT_MXFAST
/ item_size
- n
;
351 ptrdiff_t half_again
= n
>> 1;
352 ptrdiff_t incr_estimate
= max (tiny_max
, half_again
);
354 /* Adjust the increment according to three constraints: NITEMS_INCR_MIN,
355 NITEMS_MAX, and what the C language can represent safely. */
356 ptrdiff_t C_language_max
= min (PTRDIFF_MAX
, SIZE_MAX
) / item_size
;
357 ptrdiff_t n_max
= (0 <= nitems_max
&& nitems_max
< C_language_max
358 ? nitems_max
: C_language_max
);
359 ptrdiff_t nitems_incr_max
= n_max
- n
;
360 ptrdiff_t incr
= max (nitems_incr_min
, min (incr_estimate
, nitems_incr_max
));
362 eassert (0 < item_size
&& 0 < nitems_incr_min
&& 0 <= n
&& -1 <= nitems_max
);
365 if (nitems_incr_max
< incr
)
366 memory_full (SIZE_MAX
);
368 pa
= xrealloc (pa
, n
* item_size
);
374 /* Like strdup, but uses xmalloc. */
377 xstrdup (const char *s
)
381 size
= strlen (s
) + 1;
382 return memcpy (xmalloc_atomic (size
), s
, size
);
385 /* Like above, but duplicates Lisp string to C string. */
388 xlispstrdup (Lisp_Object string
)
390 ptrdiff_t size
= SBYTES (string
) + 1;
391 return memcpy (xmalloc_atomic (size
), SSDATA (string
), size
);
394 /* Assign to *PTR a copy of STRING, freeing any storage *PTR formerly
395 pointed to. If STRING is null, assign it without copying anything.
396 Allocate before freeing, to avoid a dangling pointer if allocation
400 dupstring (char **ptr
, char const *string
)
403 *ptr
= string
? xstrdup (string
) : 0;
408 /* Like putenv, but (1) use the equivalent of xmalloc and (2) the
409 argument is a const pointer. */
412 xputenv (char const *string
)
414 if (putenv ((char *) string
) != 0)
418 /***********************************************************************
420 ***********************************************************************/
422 /* Return a new interval. */
427 INTERVAL val
= xmalloc (sizeof (struct interval
));
428 RESET_INTERVAL (val
);
432 /***********************************************************************
434 ***********************************************************************/
436 /* Initialize string allocation. Called from init_alloc_once. */
441 empty_unibyte_string
= make_empty_string (0);
442 empty_multibyte_string
= make_empty_string (1);
445 /* Return a new Lisp_String. */
447 static struct Lisp_String
*
448 allocate_string (void)
450 struct Lisp_String
*p
;
452 p
= xmalloc (sizeof *p
);
453 SCM_NEWSMOB (p
->self
, lisp_string_tag
, p
);
458 /* Set up Lisp_String S for holding NCHARS characters, NBYTES bytes,
459 plus a NUL byte at the end. Allocate an sdata structure for S, and
460 set S->data to its `u.data' member. Store a NUL byte at the end of
461 S->data. Set S->size to NCHARS and S->size_byte to NBYTES. Free
462 S->data if it was initially non-null. */
465 allocate_string_data (struct Lisp_String
*s
,
466 EMACS_INT nchars
, EMACS_INT nbytes
)
470 if (STRING_BYTES_BOUND
< nbytes
)
473 data
= GC_MALLOC_ATOMIC (nbytes
+ 1);
476 s
->size_byte
= nbytes
;
477 s
->data
[nbytes
] = '\0';
481 string_overflow (void)
483 error ("Maximum string size exceeded");
487 make_empty_string (int multibyte
)
490 struct Lisp_String
*s
;
492 s
= allocate_string ();
493 allocate_string_data (s
, 0, 0);
494 XSETSTRING (string
, s
);
496 STRING_SET_UNIBYTE (string
);
501 DEFUN ("make-string", Fmake_string
, Smake_string
, 2, 2, 0,
502 doc
: /* Return a newly created string of length LENGTH, with INIT in each element.
503 LENGTH must be an integer.
504 INIT must be an integer that represents a character. */)
505 (Lisp_Object length
, Lisp_Object init
)
507 register Lisp_Object val
;
511 CHECK_NATNUM (length
);
512 CHECK_CHARACTER (init
);
515 if (ASCII_CHAR_P (c
))
517 nbytes
= XINT (length
);
518 val
= make_uninit_string (nbytes
);
519 memset (SDATA (val
), c
, nbytes
);
520 SDATA (val
)[nbytes
] = 0;
524 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
525 ptrdiff_t len
= CHAR_STRING (c
, str
);
526 EMACS_INT string_len
= XINT (length
);
527 unsigned char *p
, *beg
, *end
;
529 if (string_len
> STRING_BYTES_BOUND
/ len
)
531 nbytes
= len
* string_len
;
532 val
= make_uninit_multibyte_string (string_len
, nbytes
);
533 for (beg
= SDATA (val
), p
= beg
, end
= beg
+ nbytes
; p
< end
; p
+= len
)
535 /* First time we just copy `str' to the data of `val'. */
537 memcpy (p
, str
, len
);
540 /* Next time we copy largest possible chunk from
541 initialized to uninitialized part of `val'. */
542 len
= min (p
- beg
, end
- p
);
543 memcpy (p
, beg
, len
);
552 /* Fill A with 1 bits if INIT is non-nil, and with 0 bits otherwise.
556 bool_vector_fill (Lisp_Object a
, Lisp_Object init
)
558 EMACS_INT nbits
= bool_vector_size (a
);
561 unsigned char *data
= bool_vector_uchar_data (a
);
562 int pattern
= NILP (init
) ? 0 : (1 << BOOL_VECTOR_BITS_PER_CHAR
) - 1;
563 ptrdiff_t nbytes
= bool_vector_bytes (nbits
);
564 int last_mask
= ~ (~0u << ((nbits
- 1) % BOOL_VECTOR_BITS_PER_CHAR
+ 1));
565 memset (data
, pattern
, nbytes
- 1);
566 data
[nbytes
- 1] = pattern
& last_mask
;
571 /* Return a newly allocated, uninitialized bool vector of size NBITS. */
574 make_uninit_bool_vector (EMACS_INT nbits
)
577 EMACS_INT words
= bool_vector_words (nbits
);
578 EMACS_INT word_bytes
= words
* sizeof (bits_word
);
579 EMACS_INT needed_elements
= ((bool_header_size
- header_size
+ word_bytes
582 struct Lisp_Bool_Vector
*p
583 = (struct Lisp_Bool_Vector
*) allocate_vector (needed_elements
);
585 XSETPVECTYPESIZE (XVECTOR (val
), PVEC_BOOL_VECTOR
, 0, 0);
588 /* Clear padding at the end. */
590 p
->data
[words
- 1] = 0;
595 DEFUN ("make-bool-vector", Fmake_bool_vector
, Smake_bool_vector
, 2, 2, 0,
596 doc
: /* Return a new bool-vector of length LENGTH, using INIT for each element.
597 LENGTH must be a number. INIT matters only in whether it is t or nil. */)
598 (Lisp_Object length
, Lisp_Object init
)
602 CHECK_NATNUM (length
);
603 val
= make_uninit_bool_vector (XFASTINT (length
));
604 return bool_vector_fill (val
, init
);
607 DEFUN ("bool-vector", Fbool_vector
, Sbool_vector
, 0, MANY
, 0,
608 doc
: /* Return a new bool-vector with specified arguments as elements.
609 Any number of arguments, even zero arguments, are allowed.
610 usage: (bool-vector &rest OBJECTS) */)
611 (ptrdiff_t nargs
, Lisp_Object
*args
)
616 vector
= make_uninit_bool_vector (nargs
);
617 for (i
= 0; i
< nargs
; i
++)
618 bool_vector_set (vector
, i
, !NILP (args
[i
]));
623 /* Make a string from NBYTES bytes at CONTENTS, and compute the number
624 of characters from the contents. This string may be unibyte or
625 multibyte, depending on the contents. */
628 make_string (const char *contents
, ptrdiff_t nbytes
)
630 register Lisp_Object val
;
631 ptrdiff_t nchars
, multibyte_nbytes
;
633 parse_str_as_multibyte ((const unsigned char *) contents
, nbytes
,
634 &nchars
, &multibyte_nbytes
);
635 if (nbytes
== nchars
|| nbytes
!= multibyte_nbytes
)
636 /* CONTENTS contains no multibyte sequences or contains an invalid
637 multibyte sequence. We must make unibyte string. */
638 val
= make_unibyte_string (contents
, nbytes
);
640 val
= make_multibyte_string (contents
, nchars
, nbytes
);
645 /* Make an unibyte string from LENGTH bytes at CONTENTS. */
648 make_unibyte_string (const char *contents
, ptrdiff_t length
)
650 register Lisp_Object val
;
651 val
= make_uninit_string (length
);
652 memcpy (SDATA (val
), contents
, length
);
657 /* Make a multibyte string from NCHARS characters occupying NBYTES
658 bytes at CONTENTS. */
661 make_multibyte_string (const char *contents
,
662 ptrdiff_t nchars
, ptrdiff_t nbytes
)
664 register Lisp_Object val
;
665 val
= make_uninit_multibyte_string (nchars
, nbytes
);
666 memcpy (SDATA (val
), contents
, nbytes
);
671 /* Make a string from NCHARS characters occupying NBYTES bytes at
672 CONTENTS. It is a multibyte string if NBYTES != NCHARS. */
675 make_string_from_bytes (const char *contents
,
676 ptrdiff_t nchars
, ptrdiff_t nbytes
)
678 register Lisp_Object val
;
679 val
= make_uninit_multibyte_string (nchars
, nbytes
);
680 memcpy (SDATA (val
), contents
, nbytes
);
681 if (SBYTES (val
) == SCHARS (val
))
682 STRING_SET_UNIBYTE (val
);
687 /* Make a string from NCHARS characters occupying NBYTES bytes at
688 CONTENTS. The argument MULTIBYTE controls whether to label the
689 string as multibyte. If NCHARS is negative, it counts the number of
690 characters by itself. */
693 make_specified_string (const char *contents
,
694 ptrdiff_t nchars
, ptrdiff_t nbytes
, bool multibyte
)
701 nchars
= multibyte_chars_in_text ((const unsigned char *) contents
,
706 val
= make_uninit_multibyte_string (nchars
, nbytes
);
707 memcpy (SDATA (val
), contents
, nbytes
);
709 STRING_SET_UNIBYTE (val
);
714 /* Return an unibyte Lisp_String set up to hold LENGTH characters
715 occupying LENGTH bytes. */
718 make_uninit_string (EMACS_INT length
)
723 return empty_unibyte_string
;
724 val
= make_uninit_multibyte_string (length
, length
);
725 STRING_SET_UNIBYTE (val
);
730 /* Return a multibyte Lisp_String set up to hold NCHARS characters
731 which occupy NBYTES bytes. */
734 make_uninit_multibyte_string (EMACS_INT nchars
, EMACS_INT nbytes
)
737 struct Lisp_String
*s
;
742 return empty_multibyte_string
;
744 s
= allocate_string ();
746 allocate_string_data (s
, nchars
, nbytes
);
747 XSETSTRING (string
, s
);
751 /* Print arguments to BUF according to a FORMAT, then return
752 a Lisp_String initialized with the data from BUF. */
755 make_formatted_string (char *buf
, const char *format
, ...)
760 va_start (ap
, format
);
761 length
= vsprintf (buf
, format
, ap
);
763 return make_string (buf
, length
);
767 /***********************************************************************
769 ***********************************************************************/
771 /* Return a new float object with value FLOAT_VALUE. */
774 make_float (double float_value
)
776 return scm_from_double (float_value
);
780 /***********************************************************************
782 ***********************************************************************/
784 DEFUN ("cons", Fcons
, Scons
, 2, 2, 0,
785 doc
: /* Create a new cons, give it CAR and CDR as components, and return it. */)
786 (Lisp_Object car
, Lisp_Object cdr
)
788 return scm_cons (car
, cdr
);
791 /* Make a list of 1, 2, 3, 4 or 5 specified objects. */
794 list1 (Lisp_Object arg1
)
796 return Fcons (arg1
, Qnil
);
800 list2 (Lisp_Object arg1
, Lisp_Object arg2
)
802 return Fcons (arg1
, Fcons (arg2
, Qnil
));
807 list3 (Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
809 return Fcons (arg1
, Fcons (arg2
, Fcons (arg3
, Qnil
)));
814 list4 (Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
, Lisp_Object arg4
)
816 return Fcons (arg1
, Fcons (arg2
, Fcons (arg3
, Fcons (arg4
, Qnil
))));
821 list5 (Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
, Lisp_Object arg4
, Lisp_Object arg5
)
823 return Fcons (arg1
, Fcons (arg2
, Fcons (arg3
, Fcons (arg4
,
824 Fcons (arg5
, Qnil
)))));
827 /* Make a list of COUNT Lisp_Objects, where ARG is the
828 first one. Allocate conses from pure space if TYPE
829 is CONSTYPE_PURE, or allocate as usual if type is CONSTYPE_HEAP. */
832 listn (enum constype type
, ptrdiff_t count
, Lisp_Object arg
, ...)
836 Lisp_Object val
, *objp
;
838 /* Change to SAFE_ALLOCA if you hit this eassert. */
839 eassert (count
<= MAX_ALLOCA
/ word_size
);
841 objp
= alloca (count
* word_size
);
844 for (i
= 1; i
< count
; i
++)
845 objp
[i
] = va_arg (ap
, Lisp_Object
);
848 for (val
= Qnil
, i
= count
- 1; i
>= 0; i
--)
850 if (type
== CONSTYPE_PURE
)
851 val
= pure_cons (objp
[i
], val
);
852 else if (type
== CONSTYPE_HEAP
)
853 val
= Fcons (objp
[i
], val
);
860 DEFUN ("list", Flist
, Slist
, 0, MANY
, 0,
861 doc
: /* Return a newly created list with specified arguments as elements.
862 Any number of arguments, even zero arguments, are allowed.
863 usage: (list &rest OBJECTS) */)
864 (ptrdiff_t nargs
, Lisp_Object
*args
)
866 register Lisp_Object val
;
872 val
= Fcons (args
[nargs
], val
);
878 DEFUN ("make-list", Fmake_list
, Smake_list
, 2, 2, 0,
879 doc
: /* Return a newly created list of length LENGTH, with each element being INIT. */)
880 (register Lisp_Object length
, Lisp_Object init
)
882 register Lisp_Object val
;
883 register EMACS_INT size
;
885 CHECK_NATNUM (length
);
886 size
= XFASTINT (length
);
891 val
= Fcons (init
, val
);
896 val
= Fcons (init
, val
);
901 val
= Fcons (init
, val
);
906 val
= Fcons (init
, val
);
911 val
= Fcons (init
, val
);
926 /***********************************************************************
928 ***********************************************************************/
930 /* The only vector with 0 slots, allocated from pure space. */
932 Lisp_Object zero_vector
;
934 /* Called once to initialize vector allocation. */
939 struct Lisp_Vector
*p
= xmalloc (header_size
);
941 SCM_NEWSMOB (p
->header
.self
, lisp_vectorlike_tag
, p
);
943 XSETVECTOR (zero_vector
, p
);
946 /* Value is a pointer to a newly allocated Lisp_Vector structure
947 with room for LEN Lisp_Objects. */
949 static struct Lisp_Vector
*
950 allocate_vectorlike (ptrdiff_t len
)
952 struct Lisp_Vector
*p
;
955 p
= XVECTOR (zero_vector
);
958 p
= xmalloc (header_size
+ len
* word_size
);
959 SCM_NEWSMOB (p
->header
.self
, lisp_vectorlike_tag
, p
);
966 /* Allocate a vector with LEN slots. */
969 allocate_vector (EMACS_INT len
)
971 struct Lisp_Vector
*v
;
972 ptrdiff_t nbytes_max
= min (PTRDIFF_MAX
, SIZE_MAX
);
974 if (min ((nbytes_max
- header_size
) / word_size
, MOST_POSITIVE_FIXNUM
) < len
)
975 memory_full (SIZE_MAX
);
976 v
= allocate_vectorlike (len
);
977 v
->header
.size
= len
;
982 /* Allocate other vector-like structures. */
985 allocate_pseudovector (int memlen
, int lisplen
, enum pvec_type tag
)
987 struct Lisp_Vector
*v
= allocate_vectorlike (memlen
);
990 /* Catch bogus values. */
991 eassert (tag
<= PVEC_FONT
);
992 eassert (memlen
- lisplen
<= (1 << PSEUDOVECTOR_REST_BITS
) - 1);
993 eassert (lisplen
<= (1 << PSEUDOVECTOR_SIZE_BITS
) - 1);
995 /* Only the first lisplen slots will be traced normally by the GC. */
996 for (i
= 0; i
< lisplen
; ++i
)
997 v
->contents
[i
] = Qnil
;
999 XSETPVECTYPESIZE (v
, tag
, lisplen
, memlen
- lisplen
);
1004 allocate_buffer (void)
1006 struct buffer
*b
= xmalloc (sizeof *b
);
1008 SCM_NEWSMOB (b
->header
.self
, lisp_vectorlike_tag
, b
);
1009 BUFFER_PVEC_INIT (b
);
1010 /* Put B on the chain of all buffers including killed ones. */
1011 b
->next
= all_buffers
;
1013 /* Note that the rest fields of B are not initialized. */
1017 struct Lisp_Hash_Table
*
1018 allocate_hash_table (void)
1020 return ALLOCATE_PSEUDOVECTOR (struct Lisp_Hash_Table
, count
, PVEC_HASH_TABLE
);
1024 allocate_window (void)
1028 w
= ALLOCATE_PSEUDOVECTOR (struct window
, current_matrix
, PVEC_WINDOW
);
1029 /* Users assumes that non-Lisp data is zeroed. */
1030 memset (&w
->current_matrix
, 0,
1031 sizeof (*w
) - offsetof (struct window
, current_matrix
));
1036 allocate_terminal (void)
1040 t
= ALLOCATE_PSEUDOVECTOR (struct terminal
, next_terminal
, PVEC_TERMINAL
);
1041 /* Users assumes that non-Lisp data is zeroed. */
1042 memset (&t
->next_terminal
, 0,
1043 sizeof (*t
) - offsetof (struct terminal
, next_terminal
));
1048 allocate_frame (void)
1052 f
= ALLOCATE_PSEUDOVECTOR (struct frame
, face_cache
, PVEC_FRAME
);
1053 /* Users assumes that non-Lisp data is zeroed. */
1054 memset (&f
->face_cache
, 0,
1055 sizeof (*f
) - offsetof (struct frame
, face_cache
));
1059 struct Lisp_Process
*
1060 allocate_process (void)
1062 struct Lisp_Process
*p
;
1064 p
= ALLOCATE_PSEUDOVECTOR (struct Lisp_Process
, pid
, PVEC_PROCESS
);
1065 /* Users assumes that non-Lisp data is zeroed. */
1067 sizeof (*p
) - offsetof (struct Lisp_Process
, pid
));
1071 DEFUN ("make-vector", Fmake_vector
, Smake_vector
, 2, 2, 0,
1072 doc
: /* Return a newly created vector of length LENGTH, with each element being INIT.
1073 See also the function `vector'. */)
1074 (register Lisp_Object length
, Lisp_Object init
)
1077 register ptrdiff_t sizei
;
1078 register ptrdiff_t i
;
1079 register struct Lisp_Vector
*p
;
1081 CHECK_NATNUM (length
);
1083 p
= allocate_vector (XFASTINT (length
));
1084 sizei
= XFASTINT (length
);
1085 for (i
= 0; i
< sizei
; i
++)
1086 p
->contents
[i
] = init
;
1088 XSETVECTOR (vector
, p
);
1093 DEFUN ("vector", Fvector
, Svector
, 0, MANY
, 0,
1094 doc
: /* Return a newly created vector with specified arguments as elements.
1095 Any number of arguments, even zero arguments, are allowed.
1096 usage: (vector &rest OBJECTS) */)
1097 (ptrdiff_t nargs
, Lisp_Object
*args
)
1100 register Lisp_Object val
= make_uninit_vector (nargs
);
1101 register struct Lisp_Vector
*p
= XVECTOR (val
);
1103 for (i
= 0; i
< nargs
; i
++)
1104 p
->contents
[i
] = args
[i
];
1109 make_byte_code (struct Lisp_Vector
*v
)
1111 /* Don't allow the global zero_vector to become a byte code object. */
1112 eassert (0 < v
->header
.size
);
1114 if (v
->header
.size
> 1 && STRINGP (v
->contents
[1])
1115 && STRING_MULTIBYTE (v
->contents
[1]))
1116 /* BYTECODE-STRING must have been produced by Emacs 20.2 or the
1117 earlier because they produced a raw 8-bit string for byte-code
1118 and now such a byte-code string is loaded as multibyte while
1119 raw 8-bit characters converted to multibyte form. Thus, now we
1120 must convert them back to the original unibyte form. */
1121 v
->contents
[1] = Fstring_as_unibyte (v
->contents
[1]);
1122 XSETPVECTYPE (v
, PVEC_COMPILED
);
1125 DEFUN ("make-byte-code", Fmake_byte_code
, Smake_byte_code
, 4, MANY
, 0,
1126 doc
: /* Create a byte-code object with specified arguments as elements.
1127 The arguments should be the ARGLIST, bytecode-string BYTE-CODE, constant
1128 vector CONSTANTS, maximum stack size DEPTH, (optional) DOCSTRING,
1129 and (optional) INTERACTIVE-SPEC.
1130 The first four arguments are required; at most six have any
1132 The ARGLIST can be either like the one of `lambda', in which case the arguments
1133 will be dynamically bound before executing the byte code, or it can be an
1134 integer of the form NNNNNNNRMMMMMMM where the 7bit MMMMMMM specifies the
1135 minimum number of arguments, the 7-bit NNNNNNN specifies the maximum number
1136 of arguments (ignoring &rest) and the R bit specifies whether there is a &rest
1137 argument to catch the left-over arguments. If such an integer is used, the
1138 arguments will not be dynamically bound but will be instead pushed on the
1139 stack before executing the byte-code.
1140 usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS) */)
1141 (ptrdiff_t nargs
, Lisp_Object
*args
)
1144 register Lisp_Object val
= make_uninit_vector (nargs
);
1145 register struct Lisp_Vector
*p
= XVECTOR (val
);
1147 /* We used to purecopy everything here, if purify-flag was set. This worked
1148 OK for Emacs-23, but with Emacs-24's lexical binding code, it can be
1149 dangerous, since make-byte-code is used during execution to build
1150 closures, so any closure built during the preload phase would end up
1151 copied into pure space, including its free variables, which is sometimes
1152 just wasteful and other times plainly wrong (e.g. those free vars may want
1155 for (i
= 0; i
< nargs
; i
++)
1156 p
->contents
[i
] = args
[i
];
1158 XSETCOMPILED (val
, p
);
1164 /***********************************************************************
1166 ***********************************************************************/
1169 initialize_symbol (Lisp_Object val
, Lisp_Object name
)
1173 scm_module_define (symbol_module
, val
, scm_c_make_vector (5, SCM_BOOL_F
));
1175 SET_SYMBOL_SELF (p
, val
);
1176 scm_module_define (plist_module
, val
, Qnil
);
1177 SET_SYMBOL_REDIRECT (p
, SYMBOL_PLAINVAL
);
1178 SET_SYMBOL_VAL (p
, Qunbound
);
1179 scm_module_define (function_module
, val
, Qnil
);
1180 SET_SYMBOL_CONSTANT (p
, 0);
1181 SET_SYMBOL_DECLARED_SPECIAL (p
, false);
1184 DEFUN ("make-symbol", Fmake_symbol
, Smake_symbol
, 1, 1, 0,
1185 doc
: /* Return a newly allocated uninterned symbol whose name is NAME.
1186 Its value is void, and its function definition and property list are nil. */)
1189 register Lisp_Object val
;
1191 CHECK_STRING (name
);
1193 val
= scm_make_symbol (scm_from_utf8_stringn (SSDATA (name
),
1195 initialize_symbol (val
, name
);
1201 /***********************************************************************
1202 Marker (Misc) Allocation
1203 ***********************************************************************/
1205 /* Return a newly allocated Lisp_Misc object of specified TYPE. */
1208 allocate_misc (enum Lisp_Misc_Type type
)
1213 p
= xmalloc (sizeof *p
);
1214 SCM_NEWSMOB (p
->u_any
.self
, lisp_misc_tag
, p
);
1216 XMISCANY (val
)->type
= type
;
1220 /* Free a Lisp_Misc object. */
1223 free_misc (Lisp_Object misc
)
1228 /* Verify properties of Lisp_Save_Value's representation
1229 that are assumed here and elsewhere. */
1231 verify (SAVE_UNUSED
== 0);
1232 verify (((SAVE_INTEGER
| SAVE_POINTER
| SAVE_FUNCPOINTER
| SAVE_OBJECT
)
1236 /* Return Lisp_Save_Value objects for the various combinations
1237 that callers need. */
1240 make_save_int_int_int (ptrdiff_t a
, ptrdiff_t b
, ptrdiff_t c
)
1242 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1243 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1244 p
->save_type
= SAVE_TYPE_INT_INT_INT
;
1245 p
->data
[0].integer
= a
;
1246 p
->data
[1].integer
= b
;
1247 p
->data
[2].integer
= c
;
1252 make_save_obj_obj_obj_obj (Lisp_Object a
, Lisp_Object b
, Lisp_Object c
,
1255 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1256 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1257 p
->save_type
= SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
;
1258 p
->data
[0].object
= a
;
1259 p
->data
[1].object
= b
;
1260 p
->data
[2].object
= c
;
1261 p
->data
[3].object
= d
;
1266 make_save_ptr (void *a
)
1268 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1269 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1270 p
->save_type
= SAVE_POINTER
;
1271 p
->data
[0].pointer
= a
;
1276 make_save_ptr_int (void *a
, ptrdiff_t b
)
1278 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1279 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1280 p
->save_type
= SAVE_TYPE_PTR_INT
;
1281 p
->data
[0].pointer
= a
;
1282 p
->data
[1].integer
= b
;
1286 #if ! (defined USE_X_TOOLKIT || defined USE_GTK)
1288 make_save_ptr_ptr (void *a
, void *b
)
1290 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1291 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1292 p
->save_type
= SAVE_TYPE_PTR_PTR
;
1293 p
->data
[0].pointer
= a
;
1294 p
->data
[1].pointer
= b
;
1300 make_save_funcptr_ptr_obj (void (*a
) (void), void *b
, Lisp_Object c
)
1302 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1303 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1304 p
->save_type
= SAVE_TYPE_FUNCPTR_PTR_OBJ
;
1305 p
->data
[0].funcpointer
= a
;
1306 p
->data
[1].pointer
= b
;
1307 p
->data
[2].object
= c
;
1311 /* Return a Lisp_Save_Value object that represents an array A
1312 of N Lisp objects. */
1315 make_save_memory (Lisp_Object
*a
, ptrdiff_t n
)
1317 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1318 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1319 p
->save_type
= SAVE_TYPE_MEMORY
;
1320 p
->data
[0].pointer
= a
;
1321 p
->data
[1].integer
= n
;
1325 /* Free a Lisp_Save_Value object. Do not use this function
1326 if SAVE contains pointer other than returned by xmalloc. */
1329 free_save_value (Lisp_Object save
)
1331 xfree (XSAVE_POINTER (save
, 0));
1335 /* Return a Lisp_Misc_Overlay object with specified START, END and PLIST. */
1338 build_overlay (Lisp_Object start
, Lisp_Object end
, Lisp_Object plist
)
1340 register Lisp_Object overlay
;
1342 overlay
= allocate_misc (Lisp_Misc_Overlay
);
1343 OVERLAY_START (overlay
) = start
;
1344 OVERLAY_END (overlay
) = end
;
1345 set_overlay_plist (overlay
, plist
);
1346 XOVERLAY (overlay
)->next
= NULL
;
1350 DEFUN ("make-marker", Fmake_marker
, Smake_marker
, 0, 0, 0,
1351 doc
: /* Return a newly allocated marker which does not point at any place. */)
1354 register Lisp_Object val
;
1355 register struct Lisp_Marker
*p
;
1357 val
= allocate_misc (Lisp_Misc_Marker
);
1363 p
->insertion_type
= 0;
1364 p
->need_adjustment
= 0;
1368 /* Return a newly allocated marker which points into BUF
1369 at character position CHARPOS and byte position BYTEPOS. */
1372 build_marker (struct buffer
*buf
, ptrdiff_t charpos
, ptrdiff_t bytepos
)
1375 struct Lisp_Marker
*m
;
1377 /* No dead buffers here. */
1378 eassert (BUFFER_LIVE_P (buf
));
1380 /* Every character is at least one byte. */
1381 eassert (charpos
<= bytepos
);
1383 obj
= allocate_misc (Lisp_Misc_Marker
);
1386 m
->charpos
= charpos
;
1387 m
->bytepos
= bytepos
;
1388 m
->insertion_type
= 0;
1389 m
->need_adjustment
= 0;
1390 m
->next
= BUF_MARKERS (buf
);
1391 BUF_MARKERS (buf
) = m
;
1395 /* Return a newly created vector or string with specified arguments as
1396 elements. If all the arguments are characters that can fit
1397 in a string of events, make a string; otherwise, make a vector.
1399 Any number of arguments, even zero arguments, are allowed. */
1402 make_event_array (ptrdiff_t nargs
, Lisp_Object
*args
)
1406 for (i
= 0; i
< nargs
; i
++)
1407 /* The things that fit in a string
1408 are characters that are in 0...127,
1409 after discarding the meta bit and all the bits above it. */
1410 if (!INTEGERP (args
[i
])
1411 || (XINT (args
[i
]) & ~(-CHAR_META
)) >= 0200)
1412 return Fvector (nargs
, args
);
1414 /* Since the loop exited, we know that all the things in it are
1415 characters, so we can make a string. */
1419 result
= Fmake_string (make_number (nargs
), make_number (0));
1420 for (i
= 0; i
< nargs
; i
++)
1422 SSET (result
, i
, XINT (args
[i
]));
1423 /* Move the meta bit to the right place for a string char. */
1424 if (XINT (args
[i
]) & CHAR_META
)
1425 SSET (result
, i
, SREF (result
, i
) | 0x80);
1434 /************************************************************************
1435 Memory Full Handling
1436 ************************************************************************/
1439 /* Called if xmalloc (NBYTES) returns zero. If NBYTES == SIZE_MAX,
1440 there may have been size_t overflow so that xmalloc was never
1441 called, or perhaps xmalloc was invoked successfully but the
1442 resulting pointer had problems fitting into a tagged EMACS_INT. In
1443 either case this counts as memory being full even though xmalloc
1447 memory_full (size_t nbytes
)
1449 /* Do not go into hysterics merely because a large request failed. */
1450 bool enough_free_memory
= 0;
1451 if (SPARE_MEMORY
< nbytes
)
1453 void *p
= xmalloc_atomic_unsafe (SPARE_MEMORY
);
1457 enough_free_memory
= 1;
1461 if (! enough_free_memory
)
1465 /* The first time we get here, free the spare memory. */
1468 xfree (spare_memory
);
1469 spare_memory
= NULL
;
1473 /* This used to call error, but if we've run out of memory, we could
1474 get infinite recursion trying to build the string. */
1475 xsignal (Qnil
, Vmemory_signal_data
);
1478 /* If we released our reserve (due to running out of memory),
1479 and we have a fair amount free once again,
1480 try to set aside another reserve in case we run out once more.
1482 This is called when a relocatable block is freed in ralloc.c,
1483 and also directly from this file, in case we're not using ralloc.c. */
1486 refill_memory_reserve (void)
1488 if (spare_memory
== NULL
)
1489 spare_memory
= xmalloc_atomic_unsafe (SPARE_MEMORY
);
1492 Vmemory_full
= Qnil
;
1495 /* Determine whether it is safe to access memory at address P. */
1497 valid_pointer_p (void *p
)
1500 return w32_valid_pointer_p (p
, 16);
1504 /* Obviously, we cannot just access it (we would SEGV trying), so we
1505 trick the o/s to tell us whether p is a valid pointer.
1506 Unfortunately, we cannot use NULL_DEVICE here, as emacs_write may
1507 not validate p in that case. */
1509 if (emacs_pipe (fd
) == 0)
1511 bool valid
= emacs_write (fd
[1], p
, 16) == 16;
1512 emacs_close (fd
[1]);
1513 emacs_close (fd
[0]);
1521 /* Return 2 if OBJ is a killed or special buffer object, 1 if OBJ is a
1522 valid lisp object, 0 if OBJ is NOT a valid lisp object, or -1 if we
1523 cannot validate OBJ. This function can be quite slow, so its primary
1524 use is the manual debugging. The only exception is print_object, where
1525 we use it to check whether the memory referenced by the pointer of
1526 Lisp_Save_Value object contains valid objects. */
1529 valid_lisp_object_p (Lisp_Object obj
)
1536 p
= (void *) SCM2PTR (obj
);
1538 if (p
== &buffer_defaults
|| p
== &buffer_local_symbols
)
1541 return valid_pointer_p (p
);
1544 /* If GC_MARK_STACK, return 1 if STR is a relocatable data of Lisp_String
1545 (i.e. there is a non-pure Lisp_Object X so that SDATA (X) == STR) and 0
1546 if not. Otherwise we can't rely on valid_lisp_object_p and return -1.
1547 This function is slow and should be used for debugging purposes. */
1550 relocatable_string_data_p (const char *str
)
1555 /***********************************************************************
1556 Pure Storage Compatibility Functions
1557 ***********************************************************************/
1560 check_pure_size (void)
1566 make_pure_string (const char *data
,
1567 ptrdiff_t nchars
, ptrdiff_t nbytes
, bool multibyte
)
1569 return make_specified_string (data
, nchars
, nbytes
, multibyte
);
1573 make_pure_c_string (const char *data
, ptrdiff_t nchars
)
1575 return build_string (data
);
1579 pure_cons (Lisp_Object car
, Lisp_Object cdr
)
1581 return Fcons (car
, cdr
);
1584 DEFUN ("purecopy", Fpurecopy
, Spurecopy
, 1, 1, 0,
1585 doc
: /* Return OBJ. */)
1586 (register Lisp_Object obj
)
1591 /***********************************************************************
1593 ***********************************************************************/
1596 staticpro (Lisp_Object
*varaddress
)
1601 DEFUN ("garbage-collect", Fgarbage_collect
, Sgarbage_collect
, 0, 0, "",
1602 doc
: /* Reclaim storage for Lisp objects no longer needed.
1603 Garbage collection happens automatically if you cons more than
1604 `gc-cons-threshold' bytes of Lisp data since previous garbage collection.
1605 `garbage-collect' normally returns a list with info on amount of space in use,
1606 where each entry has the form (NAME SIZE USED FREE), where:
1607 - NAME is a symbol describing the kind of objects this entry represents,
1608 - SIZE is the number of bytes used by each one,
1609 - USED is the number of those objects that were found live in the heap,
1610 - FREE is the number of those objects that are not live but that Emacs
1611 keeps around for future allocations (maybe because it does not know how
1612 to return them to the OS).
1613 However, if there was overflow in pure space, `garbage-collect'
1614 returns nil, because real GC can't be done.
1615 See Info node `(elisp)Garbage Collection'. */)
1622 #ifdef ENABLE_CHECKING
1624 bool suppress_checking
;
1627 die (const char *msg
, const char *file
, int line
)
1629 fprintf (stderr
, "\r\n%s:%d: Emacs fatal error: assertion failed: %s\r\n",
1631 terminate_due_to_signal (SIGABRT
, INT_MAX
);
1635 /* Initialization. */
1638 init_alloc_once (void)
1640 lisp_misc_tag
= scm_make_smob_type ("elisp-misc", 0);
1641 lisp_string_tag
= scm_make_smob_type ("elisp-string", 0);
1642 lisp_vectorlike_tag
= scm_make_smob_type ("elisp-vectorlike", 0);
1644 /* Used to do Vpurify_flag = Qt here, but Qt isn't set up yet! */
1649 refill_memory_reserve ();
1650 gc_cons_threshold
= GC_DEFAULT_THRESHOLD
;
1657 Vgc_elapsed
= make_float (0.0);
1661 valgrind_p
= RUNNING_ON_VALGRIND
!= 0;
1666 syms_of_alloc (void)
1670 DEFVAR_INT ("gc-cons-threshold", gc_cons_threshold
,
1671 doc
: /* Number of bytes of consing between garbage collections.
1672 Garbage collection can happen automatically once this many bytes have been
1673 allocated since the last garbage collection. All data types count.
1675 Garbage collection happens automatically only when `eval' is called.
1677 By binding this temporarily to a large number, you can effectively
1678 prevent garbage collection during a part of the program.
1679 See also `gc-cons-percentage'. */);
1681 DEFVAR_LISP ("gc-cons-percentage", Vgc_cons_percentage
,
1682 doc
: /* Portion of the heap used for allocation.
1683 Garbage collection can happen automatically once this portion of the heap
1684 has been allocated since the last garbage collection.
1685 If this portion is smaller than `gc-cons-threshold', this is ignored. */);
1686 Vgc_cons_percentage
= make_float (0.1);
1688 DEFVAR_INT ("pure-bytes-used", pure_bytes_used
,
1689 doc
: /* Number of bytes of shareable Lisp data allocated so far. */);
1691 DEFVAR_LISP ("purify-flag", Vpurify_flag
,
1692 doc
: /* Non-nil means loading Lisp code in order to dump an executable.
1693 This means that certain objects should be allocated in shared (pure) space.
1694 It can also be set to a hash-table, in which case this table is used to
1695 do hash-consing of the objects allocated to pure space. */);
1697 DEFVAR_BOOL ("garbage-collection-messages", garbage_collection_messages
,
1698 doc
: /* Non-nil means display messages at start and end of garbage collection. */);
1699 garbage_collection_messages
= 0;
1701 DEFVAR_LISP ("post-gc-hook", Vpost_gc_hook
,
1702 doc
: /* Hook run after garbage collection has finished. */);
1703 Vpost_gc_hook
= Qnil
;
1704 DEFSYM (Qpost_gc_hook
, "post-gc-hook");
1706 DEFVAR_LISP ("memory-signal-data", Vmemory_signal_data
,
1707 doc
: /* Precomputed `signal' argument for memory-full error. */);
1708 /* We build this in advance because if we wait until we need it, we might
1709 not be able to allocate the memory to hold it. */
1711 = listn (CONSTYPE_PURE
, 2, Qerror
,
1712 build_pure_c_string ("Memory exhausted--use M-x save-some-buffers then exit and restart Emacs"));
1714 DEFVAR_LISP ("memory-full", Vmemory_full
,
1715 doc
: /* Non-nil means Emacs cannot get much more Lisp memory. */);
1716 Vmemory_full
= Qnil
;
1718 DEFSYM (Qgc_cons_threshold
, "gc-cons-threshold");
1719 DEFSYM (Qchar_table_extra_slots
, "char-table-extra-slots");
1721 DEFVAR_LISP ("gc-elapsed", Vgc_elapsed
,
1722 doc
: /* Accumulated time elapsed in garbage collections.
1723 The time is in seconds as a floating point value. */);
1724 DEFVAR_INT ("gcs-done", gcs_done
,
1725 doc
: /* Accumulated number of garbage collections done. */);
1728 /* When compiled with GCC, GDB might say "No enum type named
1729 pvec_type" if we don't have at least one symbol with that type, and
1730 then xbacktrace could fail. Similarly for the other enums and
1731 their values. Some non-GCC compilers don't like these constructs. */
1735 enum CHARTAB_SIZE_BITS CHARTAB_SIZE_BITS
;
1736 enum CHAR_TABLE_STANDARD_SLOTS CHAR_TABLE_STANDARD_SLOTS
;
1737 enum char_bits char_bits
;
1738 enum DEFAULT_HASH_SIZE DEFAULT_HASH_SIZE
;
1739 enum Lisp_Bits Lisp_Bits
;
1740 enum Lisp_Compiled Lisp_Compiled
;
1741 enum maxargs maxargs
;
1742 enum MAX_ALLOCA MAX_ALLOCA
;
1743 enum More_Lisp_Bits More_Lisp_Bits
;
1744 enum pvec_type pvec_type
;
1745 } const EXTERNALLY_VISIBLE gdb_make_enums_visible
= {0};
1746 #endif /* __GNUC__ */