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 ***********************************************************************/
1168 DEFUN ("make-symbol", Fmake_symbol
, Smake_symbol
, 1, 1, 0,
1169 doc
: /* Return a newly allocated uninterned symbol whose name is NAME.
1170 Its value is void, and its function definition and property list are nil. */)
1173 register Lisp_Object val
;
1175 CHECK_STRING (name
);
1177 val
= scm_make_symbol (scm_from_utf8_stringn (SSDATA (name
),
1184 /***********************************************************************
1185 Marker (Misc) Allocation
1186 ***********************************************************************/
1188 /* Return a newly allocated Lisp_Misc object of specified TYPE. */
1191 allocate_misc (enum Lisp_Misc_Type type
)
1196 p
= xmalloc (sizeof *p
);
1197 SCM_NEWSMOB (p
->u_any
.self
, lisp_misc_tag
, p
);
1199 XMISCANY (val
)->type
= type
;
1203 /* Free a Lisp_Misc object. */
1206 free_misc (Lisp_Object misc
)
1211 /* Verify properties of Lisp_Save_Value's representation
1212 that are assumed here and elsewhere. */
1214 verify (SAVE_UNUSED
== 0);
1215 verify (((SAVE_INTEGER
| SAVE_POINTER
| SAVE_FUNCPOINTER
| SAVE_OBJECT
)
1219 /* Return Lisp_Save_Value objects for the various combinations
1220 that callers need. */
1223 make_save_int_int_int (ptrdiff_t a
, ptrdiff_t b
, ptrdiff_t c
)
1225 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1226 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1227 p
->save_type
= SAVE_TYPE_INT_INT_INT
;
1228 p
->data
[0].integer
= a
;
1229 p
->data
[1].integer
= b
;
1230 p
->data
[2].integer
= c
;
1235 make_save_obj_obj_obj_obj (Lisp_Object a
, Lisp_Object b
, Lisp_Object c
,
1238 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1239 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1240 p
->save_type
= SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
;
1241 p
->data
[0].object
= a
;
1242 p
->data
[1].object
= b
;
1243 p
->data
[2].object
= c
;
1244 p
->data
[3].object
= d
;
1249 make_save_ptr (void *a
)
1251 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1252 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1253 p
->save_type
= SAVE_POINTER
;
1254 p
->data
[0].pointer
= a
;
1259 make_save_ptr_int (void *a
, ptrdiff_t b
)
1261 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1262 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1263 p
->save_type
= SAVE_TYPE_PTR_INT
;
1264 p
->data
[0].pointer
= a
;
1265 p
->data
[1].integer
= b
;
1269 #if ! (defined USE_X_TOOLKIT || defined USE_GTK)
1271 make_save_ptr_ptr (void *a
, void *b
)
1273 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1274 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1275 p
->save_type
= SAVE_TYPE_PTR_PTR
;
1276 p
->data
[0].pointer
= a
;
1277 p
->data
[1].pointer
= b
;
1283 make_save_funcptr_ptr_obj (void (*a
) (void), void *b
, Lisp_Object c
)
1285 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1286 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1287 p
->save_type
= SAVE_TYPE_FUNCPTR_PTR_OBJ
;
1288 p
->data
[0].funcpointer
= a
;
1289 p
->data
[1].pointer
= b
;
1290 p
->data
[2].object
= c
;
1294 /* Return a Lisp_Save_Value object that represents an array A
1295 of N Lisp objects. */
1298 make_save_memory (Lisp_Object
*a
, ptrdiff_t n
)
1300 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1301 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1302 p
->save_type
= SAVE_TYPE_MEMORY
;
1303 p
->data
[0].pointer
= a
;
1304 p
->data
[1].integer
= n
;
1308 /* Free a Lisp_Save_Value object. Do not use this function
1309 if SAVE contains pointer other than returned by xmalloc. */
1312 free_save_value (Lisp_Object save
)
1314 xfree (XSAVE_POINTER (save
, 0));
1318 /* Return a Lisp_Misc_Overlay object with specified START, END and PLIST. */
1321 build_overlay (Lisp_Object start
, Lisp_Object end
, Lisp_Object plist
)
1323 register Lisp_Object overlay
;
1325 overlay
= allocate_misc (Lisp_Misc_Overlay
);
1326 OVERLAY_START (overlay
) = start
;
1327 OVERLAY_END (overlay
) = end
;
1328 set_overlay_plist (overlay
, plist
);
1329 XOVERLAY (overlay
)->next
= NULL
;
1333 DEFUN ("make-marker", Fmake_marker
, Smake_marker
, 0, 0, 0,
1334 doc
: /* Return a newly allocated marker which does not point at any place. */)
1337 register Lisp_Object val
;
1338 register struct Lisp_Marker
*p
;
1340 val
= allocate_misc (Lisp_Misc_Marker
);
1346 p
->insertion_type
= 0;
1347 p
->need_adjustment
= 0;
1351 /* Return a newly allocated marker which points into BUF
1352 at character position CHARPOS and byte position BYTEPOS. */
1355 build_marker (struct buffer
*buf
, ptrdiff_t charpos
, ptrdiff_t bytepos
)
1358 struct Lisp_Marker
*m
;
1360 /* No dead buffers here. */
1361 eassert (BUFFER_LIVE_P (buf
));
1363 /* Every character is at least one byte. */
1364 eassert (charpos
<= bytepos
);
1366 obj
= allocate_misc (Lisp_Misc_Marker
);
1369 m
->charpos
= charpos
;
1370 m
->bytepos
= bytepos
;
1371 m
->insertion_type
= 0;
1372 m
->need_adjustment
= 0;
1373 m
->next
= BUF_MARKERS (buf
);
1374 BUF_MARKERS (buf
) = m
;
1378 /* Return a newly created vector or string with specified arguments as
1379 elements. If all the arguments are characters that can fit
1380 in a string of events, make a string; otherwise, make a vector.
1382 Any number of arguments, even zero arguments, are allowed. */
1385 make_event_array (ptrdiff_t nargs
, Lisp_Object
*args
)
1389 for (i
= 0; i
< nargs
; i
++)
1390 /* The things that fit in a string
1391 are characters that are in 0...127,
1392 after discarding the meta bit and all the bits above it. */
1393 if (!INTEGERP (args
[i
])
1394 || (XINT (args
[i
]) & ~(-CHAR_META
)) >= 0200)
1395 return Fvector (nargs
, args
);
1397 /* Since the loop exited, we know that all the things in it are
1398 characters, so we can make a string. */
1402 result
= Fmake_string (make_number (nargs
), make_number (0));
1403 for (i
= 0; i
< nargs
; i
++)
1405 SSET (result
, i
, XINT (args
[i
]));
1406 /* Move the meta bit to the right place for a string char. */
1407 if (XINT (args
[i
]) & CHAR_META
)
1408 SSET (result
, i
, SREF (result
, i
) | 0x80);
1417 /************************************************************************
1418 Memory Full Handling
1419 ************************************************************************/
1422 /* Called if xmalloc (NBYTES) returns zero. If NBYTES == SIZE_MAX,
1423 there may have been size_t overflow so that xmalloc was never
1424 called, or perhaps xmalloc was invoked successfully but the
1425 resulting pointer had problems fitting into a tagged EMACS_INT. In
1426 either case this counts as memory being full even though xmalloc
1430 memory_full (size_t nbytes
)
1432 /* Do not go into hysterics merely because a large request failed. */
1433 bool enough_free_memory
= 0;
1434 if (SPARE_MEMORY
< nbytes
)
1436 void *p
= xmalloc_atomic_unsafe (SPARE_MEMORY
);
1440 enough_free_memory
= 1;
1444 if (! enough_free_memory
)
1448 /* The first time we get here, free the spare memory. */
1451 xfree (spare_memory
);
1452 spare_memory
= NULL
;
1456 /* This used to call error, but if we've run out of memory, we could
1457 get infinite recursion trying to build the string. */
1458 xsignal (Qnil
, Vmemory_signal_data
);
1461 /* If we released our reserve (due to running out of memory),
1462 and we have a fair amount free once again,
1463 try to set aside another reserve in case we run out once more.
1465 This is called when a relocatable block is freed in ralloc.c,
1466 and also directly from this file, in case we're not using ralloc.c. */
1469 refill_memory_reserve (void)
1471 if (spare_memory
== NULL
)
1472 spare_memory
= xmalloc_atomic_unsafe (SPARE_MEMORY
);
1475 Vmemory_full
= Qnil
;
1478 /* Determine whether it is safe to access memory at address P. */
1480 valid_pointer_p (void *p
)
1483 return w32_valid_pointer_p (p
, 16);
1487 /* Obviously, we cannot just access it (we would SEGV trying), so we
1488 trick the o/s to tell us whether p is a valid pointer.
1489 Unfortunately, we cannot use NULL_DEVICE here, as emacs_write may
1490 not validate p in that case. */
1492 if (emacs_pipe (fd
) == 0)
1494 bool valid
= emacs_write (fd
[1], p
, 16) == 16;
1495 emacs_close (fd
[1]);
1496 emacs_close (fd
[0]);
1504 /* Return 2 if OBJ is a killed or special buffer object, 1 if OBJ is a
1505 valid lisp object, 0 if OBJ is NOT a valid lisp object, or -1 if we
1506 cannot validate OBJ. This function can be quite slow, so its primary
1507 use is the manual debugging. The only exception is print_object, where
1508 we use it to check whether the memory referenced by the pointer of
1509 Lisp_Save_Value object contains valid objects. */
1512 valid_lisp_object_p (Lisp_Object obj
)
1519 p
= (void *) SCM2PTR (obj
);
1521 if (p
== &buffer_defaults
|| p
== &buffer_local_symbols
)
1524 return valid_pointer_p (p
);
1527 /* If GC_MARK_STACK, return 1 if STR is a relocatable data of Lisp_String
1528 (i.e. there is a non-pure Lisp_Object X so that SDATA (X) == STR) and 0
1529 if not. Otherwise we can't rely on valid_lisp_object_p and return -1.
1530 This function is slow and should be used for debugging purposes. */
1533 relocatable_string_data_p (const char *str
)
1538 /***********************************************************************
1539 Pure Storage Compatibility Functions
1540 ***********************************************************************/
1543 check_pure_size (void)
1549 make_pure_string (const char *data
,
1550 ptrdiff_t nchars
, ptrdiff_t nbytes
, bool multibyte
)
1552 return make_specified_string (data
, nchars
, nbytes
, multibyte
);
1556 make_pure_c_string (const char *data
, ptrdiff_t nchars
)
1558 return build_string (data
);
1562 pure_cons (Lisp_Object car
, Lisp_Object cdr
)
1564 return Fcons (car
, cdr
);
1567 DEFUN ("purecopy", Fpurecopy
, Spurecopy
, 1, 1, 0,
1568 doc
: /* Return OBJ. */)
1569 (register Lisp_Object obj
)
1574 /***********************************************************************
1576 ***********************************************************************/
1579 staticpro (Lisp_Object
*varaddress
)
1584 DEFUN ("garbage-collect", Fgarbage_collect
, Sgarbage_collect
, 0, 0, "",
1585 doc
: /* Reclaim storage for Lisp objects no longer needed.
1586 Garbage collection happens automatically if you cons more than
1587 `gc-cons-threshold' bytes of Lisp data since previous garbage collection.
1588 `garbage-collect' normally returns a list with info on amount of space in use,
1589 where each entry has the form (NAME SIZE USED FREE), where:
1590 - NAME is a symbol describing the kind of objects this entry represents,
1591 - SIZE is the number of bytes used by each one,
1592 - USED is the number of those objects that were found live in the heap,
1593 - FREE is the number of those objects that are not live but that Emacs
1594 keeps around for future allocations (maybe because it does not know how
1595 to return them to the OS).
1596 However, if there was overflow in pure space, `garbage-collect'
1597 returns nil, because real GC can't be done.
1598 See Info node `(elisp)Garbage Collection'. */)
1605 #ifdef ENABLE_CHECKING
1607 bool suppress_checking
;
1610 die (const char *msg
, const char *file
, int line
)
1612 fprintf (stderr
, "\r\n%s:%d: Emacs fatal error: assertion failed: %s\r\n",
1614 terminate_due_to_signal (SIGABRT
, INT_MAX
);
1618 /* Initialization. */
1621 init_alloc_once (void)
1623 lisp_misc_tag
= scm_make_smob_type ("elisp-misc", 0);
1624 lisp_string_tag
= scm_make_smob_type ("elisp-string", 0);
1625 lisp_vectorlike_tag
= scm_make_smob_type ("elisp-vectorlike", 0);
1627 /* Used to do Vpurify_flag = Qt here, but Qt isn't set up yet! */
1632 refill_memory_reserve ();
1633 gc_cons_threshold
= GC_DEFAULT_THRESHOLD
;
1640 Vgc_elapsed
= make_float (0.0);
1644 valgrind_p
= RUNNING_ON_VALGRIND
!= 0;
1649 syms_of_alloc (void)
1653 DEFVAR_INT ("gc-cons-threshold", gc_cons_threshold
,
1654 doc
: /* Number of bytes of consing between garbage collections.
1655 Garbage collection can happen automatically once this many bytes have been
1656 allocated since the last garbage collection. All data types count.
1658 Garbage collection happens automatically only when `eval' is called.
1660 By binding this temporarily to a large number, you can effectively
1661 prevent garbage collection during a part of the program.
1662 See also `gc-cons-percentage'. */);
1664 DEFVAR_LISP ("gc-cons-percentage", Vgc_cons_percentage
,
1665 doc
: /* Portion of the heap used for allocation.
1666 Garbage collection can happen automatically once this portion of the heap
1667 has been allocated since the last garbage collection.
1668 If this portion is smaller than `gc-cons-threshold', this is ignored. */);
1669 Vgc_cons_percentage
= make_float (0.1);
1671 DEFVAR_INT ("pure-bytes-used", pure_bytes_used
,
1672 doc
: /* Number of bytes of shareable Lisp data allocated so far. */);
1674 DEFVAR_LISP ("purify-flag", Vpurify_flag
,
1675 doc
: /* Non-nil means loading Lisp code in order to dump an executable.
1676 This means that certain objects should be allocated in shared (pure) space.
1677 It can also be set to a hash-table, in which case this table is used to
1678 do hash-consing of the objects allocated to pure space. */);
1680 DEFVAR_BOOL ("garbage-collection-messages", garbage_collection_messages
,
1681 doc
: /* Non-nil means display messages at start and end of garbage collection. */);
1682 garbage_collection_messages
= 0;
1684 DEFVAR_LISP ("post-gc-hook", Vpost_gc_hook
,
1685 doc
: /* Hook run after garbage collection has finished. */);
1686 Vpost_gc_hook
= Qnil
;
1687 DEFSYM (Qpost_gc_hook
, "post-gc-hook");
1689 DEFVAR_LISP ("memory-signal-data", Vmemory_signal_data
,
1690 doc
: /* Precomputed `signal' argument for memory-full error. */);
1691 /* We build this in advance because if we wait until we need it, we might
1692 not be able to allocate the memory to hold it. */
1694 = listn (CONSTYPE_PURE
, 2, Qerror
,
1695 build_pure_c_string ("Memory exhausted--use M-x save-some-buffers then exit and restart Emacs"));
1697 DEFVAR_LISP ("memory-full", Vmemory_full
,
1698 doc
: /* Non-nil means Emacs cannot get much more Lisp memory. */);
1699 Vmemory_full
= Qnil
;
1701 DEFSYM (Qgc_cons_threshold
, "gc-cons-threshold");
1702 DEFSYM (Qchar_table_extra_slots
, "char-table-extra-slots");
1704 DEFVAR_LISP ("gc-elapsed", Vgc_elapsed
,
1705 doc
: /* Accumulated time elapsed in garbage collections.
1706 The time is in seconds as a floating point value. */);
1707 DEFVAR_INT ("gcs-done", gcs_done
,
1708 doc
: /* Accumulated number of garbage collections done. */);
1711 /* When compiled with GCC, GDB might say "No enum type named
1712 pvec_type" if we don't have at least one symbol with that type, and
1713 then xbacktrace could fail. Similarly for the other enums and
1714 their values. Some non-GCC compilers don't like these constructs. */
1718 enum CHARTAB_SIZE_BITS CHARTAB_SIZE_BITS
;
1719 enum CHAR_TABLE_STANDARD_SLOTS CHAR_TABLE_STANDARD_SLOTS
;
1720 enum char_bits char_bits
;
1721 enum DEFAULT_HASH_SIZE DEFAULT_HASH_SIZE
;
1722 enum Lisp_Bits Lisp_Bits
;
1723 enum Lisp_Compiled Lisp_Compiled
;
1724 enum maxargs maxargs
;
1725 enum MAX_ALLOCA MAX_ALLOCA
;
1726 enum More_Lisp_Bits More_Lisp_Bits
;
1727 enum pvec_type pvec_type
;
1728 } const EXTERNALLY_VISIBLE gdb_make_enums_visible
= {0};
1729 #endif /* __GNUC__ */