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
;
147 XFLOAT_INIT (Lisp_Object f
, double n
)
149 XFLOAT (f
)->u
.data
= n
;
153 /************************************************************************
155 ************************************************************************/
157 /* Function malloc calls this if it finds we are near exhausting storage. */
160 malloc_warning (const char *str
)
162 pending_malloc_warning
= str
;
166 /* Display an already-pending malloc warning. */
169 display_malloc_warning (void)
171 call3 (intern ("display-warning"),
173 build_string (pending_malloc_warning
),
174 intern ("emergency"));
175 pending_malloc_warning
= 0;
178 /* Called if we can't allocate relocatable space for a buffer. */
181 buffer_memory_full (ptrdiff_t nbytes
)
183 /* If buffers use the relocating allocator, no need to free
184 spare_memory, because we may have plenty of malloc space left
185 that we could get, and if we don't, the malloc that fails will
186 itself cause spare_memory to be freed. If buffers don't use the
187 relocating allocator, treat this like any other failing
191 memory_full (nbytes
);
193 /* This used to call error, but if we've run out of memory, we could
194 get infinite recursion trying to build the string. */
195 xsignal (Qnil
, Vmemory_signal_data
);
199 /* Like GC_MALLOC but check for no memory. */
202 xmalloc (size_t size
)
204 void *val
= GC_MALLOC (size
);
210 /* Like the above, but zeroes out the memory just allocated. */
213 xzalloc (size_t size
)
215 return xmalloc (size
);
218 /* Like GC_REALLOC but check for no memory. */
221 xrealloc (void *block
, size_t size
)
223 void *val
= GC_REALLOC (block
, size
);
236 /* Other parts of Emacs pass large int values to allocator functions
237 expecting ptrdiff_t. This is portable in practice, but check it to
239 verify (INT_MAX
<= PTRDIFF_MAX
);
242 /* Allocate an array of NITEMS items, each of size ITEM_SIZE.
243 Signal an error on memory exhaustion. */
246 xnmalloc (ptrdiff_t nitems
, ptrdiff_t item_size
)
248 eassert (0 <= nitems
&& 0 < item_size
);
249 if (min (PTRDIFF_MAX
, SIZE_MAX
) / item_size
< nitems
)
250 memory_full (SIZE_MAX
);
251 return xmalloc (nitems
* item_size
);
255 /* Reallocate an array PA to make it of NITEMS items, each of size ITEM_SIZE.
256 Signal an error on memory exhaustion. */
259 xnrealloc (void *pa
, ptrdiff_t nitems
, ptrdiff_t item_size
)
261 eassert (0 <= nitems
&& 0 < item_size
);
262 if (min (PTRDIFF_MAX
, SIZE_MAX
) / item_size
< nitems
)
263 memory_full (SIZE_MAX
);
264 return xrealloc (pa
, nitems
* item_size
);
268 /* Grow PA, which points to an array of *NITEMS items, and return the
269 location of the reallocated array, updating *NITEMS to reflect its
270 new size. The new array will contain at least NITEMS_INCR_MIN more
271 items, but will not contain more than NITEMS_MAX items total.
272 ITEM_SIZE is the size of each item, in bytes.
274 ITEM_SIZE and NITEMS_INCR_MIN must be positive. *NITEMS must be
275 nonnegative. If NITEMS_MAX is -1, it is treated as if it were
278 If PA is null, then allocate a new array instead of reallocating
281 If memory exhaustion occurs, set *NITEMS to zero if PA is null, and
282 signal an error (i.e., do not return).
284 Thus, to grow an array A without saving its old contents, do
285 { xfree (A); A = NULL; A = xpalloc (NULL, &AITEMS, ...); }.
286 The A = NULL avoids a dangling pointer if xpalloc exhausts memory
287 and signals an error, and later this code is reexecuted and
288 attempts to free A. */
291 xpalloc (void *pa
, ptrdiff_t *nitems
, ptrdiff_t nitems_incr_min
,
292 ptrdiff_t nitems_max
, ptrdiff_t item_size
)
294 /* The approximate size to use for initial small allocation
295 requests. This is the largest "small" request for the GNU C
297 enum { DEFAULT_MXFAST
= 64 * sizeof (size_t) / 4 };
299 /* If the array is tiny, grow it to about (but no greater than)
300 DEFAULT_MXFAST bytes. Otherwise, grow it by about 50%. */
301 ptrdiff_t n
= *nitems
;
302 ptrdiff_t tiny_max
= DEFAULT_MXFAST
/ item_size
- n
;
303 ptrdiff_t half_again
= n
>> 1;
304 ptrdiff_t incr_estimate
= max (tiny_max
, half_again
);
306 /* Adjust the increment according to three constraints: NITEMS_INCR_MIN,
307 NITEMS_MAX, and what the C language can represent safely. */
308 ptrdiff_t C_language_max
= min (PTRDIFF_MAX
, SIZE_MAX
) / item_size
;
309 ptrdiff_t n_max
= (0 <= nitems_max
&& nitems_max
< C_language_max
310 ? nitems_max
: C_language_max
);
311 ptrdiff_t nitems_incr_max
= n_max
- n
;
312 ptrdiff_t incr
= max (nitems_incr_min
, min (incr_estimate
, nitems_incr_max
));
314 eassert (0 < item_size
&& 0 < nitems_incr_min
&& 0 <= n
&& -1 <= nitems_max
);
317 if (nitems_incr_max
< incr
)
318 memory_full (SIZE_MAX
);
320 pa
= xrealloc (pa
, n
* item_size
);
326 /* Like strdup, but uses xmalloc. */
329 xstrdup (const char *s
)
333 size
= strlen (s
) + 1;
334 return memcpy (xmalloc (size
), s
, size
);
337 /* Like above, but duplicates Lisp string to C string. */
340 xlispstrdup (Lisp_Object string
)
342 ptrdiff_t size
= SBYTES (string
) + 1;
343 return memcpy (xmalloc (size
), SSDATA (string
), size
);
346 /* Assign to *PTR a copy of STRING, freeing any storage *PTR formerly
347 pointed to. If STRING is null, assign it without copying anything.
348 Allocate before freeing, to avoid a dangling pointer if allocation
352 dupstring (char **ptr
, char const *string
)
355 *ptr
= string
? xstrdup (string
) : 0;
360 /* Like putenv, but (1) use the equivalent of xmalloc and (2) the
361 argument is a const pointer. */
364 xputenv (char const *string
)
366 if (putenv ((char *) string
) != 0)
370 /* Return a newly allocated memory block of SIZE bytes, remembering
371 to free it when unwinding. */
373 record_xmalloc (size_t size
)
375 void *p
= xmalloc (size
);
376 record_unwind_protect_ptr (xfree
, p
);
380 /***********************************************************************
382 ***********************************************************************/
384 /* Return a new interval. */
389 INTERVAL val
= xmalloc (sizeof (struct interval
));
390 RESET_INTERVAL (val
);
394 /***********************************************************************
396 ***********************************************************************/
398 /* Initialize string allocation. Called from init_alloc_once. */
403 empty_unibyte_string
= make_empty_string (0);
404 empty_multibyte_string
= make_empty_string (1);
407 /* Return a new Lisp_String. */
409 static struct Lisp_String
*
410 allocate_string (void)
412 return xmalloc (sizeof (struct Lisp_String
));
416 /* Set up Lisp_String S for holding NCHARS characters, NBYTES bytes,
417 plus a NUL byte at the end. Allocate an sdata structure for S, and
418 set S->data to its `u.data' member. Store a NUL byte at the end of
419 S->data. Set S->size to NCHARS and S->size_byte to NBYTES. Free
420 S->data if it was initially non-null. */
423 allocate_string_data (struct Lisp_String
*s
,
424 EMACS_INT nchars
, EMACS_INT nbytes
)
428 if (STRING_BYTES_BOUND
< nbytes
)
431 data
= GC_MALLOC_ATOMIC (nbytes
+ 1);
434 s
->size_byte
= nbytes
;
435 s
->data
[nbytes
] = '\0';
439 string_overflow (void)
441 error ("Maximum string size exceeded");
445 make_empty_string (int multibyte
)
448 struct Lisp_String
*s
;
450 s
= allocate_string ();
451 allocate_string_data (s
, 0, 0);
452 XSETSTRING (string
, s
);
454 STRING_SET_UNIBYTE (string
);
459 DEFUN ("make-string", Fmake_string
, Smake_string
, 2, 2, 0,
460 doc
: /* Return a newly created string of length LENGTH, with INIT in each element.
461 LENGTH must be an integer.
462 INIT must be an integer that represents a character. */)
463 (Lisp_Object length
, Lisp_Object init
)
465 register Lisp_Object val
;
469 CHECK_NATNUM (length
);
470 CHECK_CHARACTER (init
);
473 if (ASCII_CHAR_P (c
))
475 nbytes
= XINT (length
);
476 val
= make_uninit_string (nbytes
);
477 memset (SDATA (val
), c
, nbytes
);
478 SDATA (val
)[nbytes
] = 0;
482 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
483 ptrdiff_t len
= CHAR_STRING (c
, str
);
484 EMACS_INT string_len
= XINT (length
);
485 unsigned char *p
, *beg
, *end
;
487 if (string_len
> STRING_BYTES_BOUND
/ len
)
489 nbytes
= len
* string_len
;
490 val
= make_uninit_multibyte_string (string_len
, nbytes
);
491 for (beg
= SDATA (val
), p
= beg
, end
= beg
+ nbytes
; p
< end
; p
+= len
)
493 /* First time we just copy `str' to the data of `val'. */
495 memcpy (p
, str
, len
);
498 /* Next time we copy largest possible chunk from
499 initialized to uninitialized part of `val'. */
500 len
= min (p
- beg
, end
- p
);
501 memcpy (p
, beg
, len
);
510 /* Fill A with 1 bits if INIT is non-nil, and with 0 bits otherwise.
514 bool_vector_fill (Lisp_Object a
, Lisp_Object init
)
516 EMACS_INT nbits
= bool_vector_size (a
);
519 unsigned char *data
= bool_vector_uchar_data (a
);
520 int pattern
= NILP (init
) ? 0 : (1 << BOOL_VECTOR_BITS_PER_CHAR
) - 1;
521 ptrdiff_t nbytes
= bool_vector_bytes (nbits
);
522 int last_mask
= ~ (~0u << ((nbits
- 1) % BOOL_VECTOR_BITS_PER_CHAR
+ 1));
523 memset (data
, pattern
, nbytes
- 1);
524 data
[nbytes
- 1] = pattern
& last_mask
;
529 /* Return a newly allocated, uninitialized bool vector of size NBITS. */
532 make_uninit_bool_vector (EMACS_INT nbits
)
535 EMACS_INT words
= bool_vector_words (nbits
);
536 EMACS_INT word_bytes
= words
* sizeof (bits_word
);
537 EMACS_INT needed_elements
= ((bool_header_size
- header_size
+ word_bytes
540 struct Lisp_Bool_Vector
*p
541 = (struct Lisp_Bool_Vector
*) allocate_vector (needed_elements
);
543 XSETPVECTYPESIZE (XVECTOR (val
), PVEC_BOOL_VECTOR
, 0, 0);
546 /* Clear padding at the end. */
548 p
->data
[words
- 1] = 0;
553 DEFUN ("make-bool-vector", Fmake_bool_vector
, Smake_bool_vector
, 2, 2, 0,
554 doc
: /* Return a new bool-vector of length LENGTH, using INIT for each element.
555 LENGTH must be a number. INIT matters only in whether it is t or nil. */)
556 (Lisp_Object length
, Lisp_Object init
)
560 CHECK_NATNUM (length
);
561 val
= make_uninit_bool_vector (XFASTINT (length
));
562 return bool_vector_fill (val
, init
);
565 DEFUN ("bool-vector", Fbool_vector
, Sbool_vector
, 0, MANY
, 0,
566 doc
: /* Return a new bool-vector with specified arguments as elements.
567 Any number of arguments, even zero arguments, are allowed.
568 usage: (bool-vector &rest OBJECTS) */)
569 (ptrdiff_t nargs
, Lisp_Object
*args
)
574 vector
= make_uninit_bool_vector (nargs
);
575 for (i
= 0; i
< nargs
; i
++)
576 bool_vector_set (vector
, i
, !NILP (args
[i
]));
581 /* Make a string from NBYTES bytes at CONTENTS, and compute the number
582 of characters from the contents. This string may be unibyte or
583 multibyte, depending on the contents. */
586 make_string (const char *contents
, ptrdiff_t nbytes
)
588 register Lisp_Object val
;
589 ptrdiff_t nchars
, multibyte_nbytes
;
591 parse_str_as_multibyte ((const unsigned char *) contents
, nbytes
,
592 &nchars
, &multibyte_nbytes
);
593 if (nbytes
== nchars
|| nbytes
!= multibyte_nbytes
)
594 /* CONTENTS contains no multibyte sequences or contains an invalid
595 multibyte sequence. We must make unibyte string. */
596 val
= make_unibyte_string (contents
, nbytes
);
598 val
= make_multibyte_string (contents
, nchars
, nbytes
);
603 /* Make an unibyte string from LENGTH bytes at CONTENTS. */
606 make_unibyte_string (const char *contents
, ptrdiff_t length
)
608 register Lisp_Object val
;
609 val
= make_uninit_string (length
);
610 memcpy (SDATA (val
), contents
, length
);
615 /* Make a multibyte string from NCHARS characters occupying NBYTES
616 bytes at CONTENTS. */
619 make_multibyte_string (const char *contents
,
620 ptrdiff_t nchars
, ptrdiff_t nbytes
)
622 register Lisp_Object val
;
623 val
= make_uninit_multibyte_string (nchars
, nbytes
);
624 memcpy (SDATA (val
), contents
, nbytes
);
629 /* Make a string from NCHARS characters occupying NBYTES bytes at
630 CONTENTS. It is a multibyte string if NBYTES != NCHARS. */
633 make_string_from_bytes (const char *contents
,
634 ptrdiff_t nchars
, ptrdiff_t nbytes
)
636 register Lisp_Object val
;
637 val
= make_uninit_multibyte_string (nchars
, nbytes
);
638 memcpy (SDATA (val
), contents
, nbytes
);
639 if (SBYTES (val
) == SCHARS (val
))
640 STRING_SET_UNIBYTE (val
);
645 /* Make a string from NCHARS characters occupying NBYTES bytes at
646 CONTENTS. The argument MULTIBYTE controls whether to label the
647 string as multibyte. If NCHARS is negative, it counts the number of
648 characters by itself. */
651 make_specified_string (const char *contents
,
652 ptrdiff_t nchars
, ptrdiff_t nbytes
, bool multibyte
)
659 nchars
= multibyte_chars_in_text ((const unsigned char *) contents
,
664 val
= make_uninit_multibyte_string (nchars
, nbytes
);
665 memcpy (SDATA (val
), contents
, nbytes
);
667 STRING_SET_UNIBYTE (val
);
672 /* Return an unibyte Lisp_String set up to hold LENGTH characters
673 occupying LENGTH bytes. */
676 make_uninit_string (EMACS_INT length
)
681 return empty_unibyte_string
;
682 val
= make_uninit_multibyte_string (length
, length
);
683 STRING_SET_UNIBYTE (val
);
688 /* Return a multibyte Lisp_String set up to hold NCHARS characters
689 which occupy NBYTES bytes. */
692 make_uninit_multibyte_string (EMACS_INT nchars
, EMACS_INT nbytes
)
695 struct Lisp_String
*s
;
700 return empty_multibyte_string
;
702 s
= allocate_string ();
704 allocate_string_data (s
, nchars
, nbytes
);
705 XSETSTRING (string
, s
);
709 /* Print arguments to BUF according to a FORMAT, then return
710 a Lisp_String initialized with the data from BUF. */
713 make_formatted_string (char *buf
, const char *format
, ...)
718 va_start (ap
, format
);
719 length
= vsprintf (buf
, format
, ap
);
721 return make_string (buf
, length
);
725 /***********************************************************************
727 ***********************************************************************/
729 /* Return a new float object with value FLOAT_VALUE. */
732 make_float (double float_value
)
734 register Lisp_Object val
;
735 XSETFLOAT (val
, xmalloc (sizeof (struct Lisp_Float
)));
736 XFLOAT_INIT (val
, float_value
);
742 /***********************************************************************
744 ***********************************************************************/
746 DEFUN ("cons", Fcons
, Scons
, 2, 2, 0,
747 doc
: /* Create a new cons, give it CAR and CDR as components, and return it. */)
748 (Lisp_Object car
, Lisp_Object cdr
)
750 register Lisp_Object val
;
752 XSETCONS (val
, xmalloc (sizeof (struct Lisp_Cons
)));
758 /* Make a list of 1, 2, 3, 4 or 5 specified objects. */
761 list1 (Lisp_Object arg1
)
763 return Fcons (arg1
, Qnil
);
767 list2 (Lisp_Object arg1
, Lisp_Object arg2
)
769 return Fcons (arg1
, Fcons (arg2
, Qnil
));
774 list3 (Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
776 return Fcons (arg1
, Fcons (arg2
, Fcons (arg3
, Qnil
)));
781 list4 (Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
, Lisp_Object arg4
)
783 return Fcons (arg1
, Fcons (arg2
, Fcons (arg3
, Fcons (arg4
, Qnil
))));
788 list5 (Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
, Lisp_Object arg4
, Lisp_Object arg5
)
790 return Fcons (arg1
, Fcons (arg2
, Fcons (arg3
, Fcons (arg4
,
791 Fcons (arg5
, Qnil
)))));
794 /* Make a list of COUNT Lisp_Objects, where ARG is the
795 first one. Allocate conses from pure space if TYPE
796 is CONSTYPE_PURE, or allocate as usual if type is CONSTYPE_HEAP. */
799 listn (enum constype type
, ptrdiff_t count
, Lisp_Object arg
, ...)
803 Lisp_Object val
, *objp
;
805 /* Change to SAFE_ALLOCA if you hit this eassert. */
806 eassert (count
<= MAX_ALLOCA
/ word_size
);
808 objp
= alloca (count
* word_size
);
811 for (i
= 1; i
< count
; i
++)
812 objp
[i
] = va_arg (ap
, Lisp_Object
);
815 for (val
= Qnil
, i
= count
- 1; i
>= 0; i
--)
817 if (type
== CONSTYPE_PURE
)
818 val
= pure_cons (objp
[i
], val
);
819 else if (type
== CONSTYPE_HEAP
)
820 val
= Fcons (objp
[i
], val
);
827 DEFUN ("list", Flist
, Slist
, 0, MANY
, 0,
828 doc
: /* Return a newly created list with specified arguments as elements.
829 Any number of arguments, even zero arguments, are allowed.
830 usage: (list &rest OBJECTS) */)
831 (ptrdiff_t nargs
, Lisp_Object
*args
)
833 register Lisp_Object val
;
839 val
= Fcons (args
[nargs
], val
);
845 DEFUN ("make-list", Fmake_list
, Smake_list
, 2, 2, 0,
846 doc
: /* Return a newly created list of length LENGTH, with each element being INIT. */)
847 (register Lisp_Object length
, Lisp_Object init
)
849 register Lisp_Object val
;
850 register EMACS_INT size
;
852 CHECK_NATNUM (length
);
853 size
= XFASTINT (length
);
858 val
= Fcons (init
, val
);
863 val
= Fcons (init
, val
);
868 val
= Fcons (init
, val
);
873 val
= Fcons (init
, val
);
878 val
= Fcons (init
, val
);
893 /***********************************************************************
895 ***********************************************************************/
897 /* The only vector with 0 slots, allocated from pure space. */
899 Lisp_Object zero_vector
;
901 /* Called once to initialize vector allocation. */
906 XSETVECTOR (zero_vector
, xmalloc (header_size
));
907 XVECTOR (zero_vector
)->header
.size
= 0;
910 /* Value is a pointer to a newly allocated Lisp_Vector structure
911 with room for LEN Lisp_Objects. */
913 static struct Lisp_Vector
*
914 allocate_vectorlike (ptrdiff_t len
)
917 return XVECTOR (zero_vector
);
919 return xmalloc (header_size
+ len
* word_size
);
923 /* Allocate a vector with LEN slots. */
926 allocate_vector (EMACS_INT len
)
928 struct Lisp_Vector
*v
;
929 ptrdiff_t nbytes_max
= min (PTRDIFF_MAX
, SIZE_MAX
);
931 if (min ((nbytes_max
- header_size
) / word_size
, MOST_POSITIVE_FIXNUM
) < len
)
932 memory_full (SIZE_MAX
);
933 v
= allocate_vectorlike (len
);
934 v
->header
.size
= len
;
939 /* Allocate other vector-like structures. */
942 allocate_pseudovector (int memlen
, int lisplen
, enum pvec_type tag
)
944 struct Lisp_Vector
*v
= allocate_vectorlike (memlen
);
947 /* Catch bogus values. */
948 eassert (tag
<= PVEC_FONT
);
949 eassert (memlen
- lisplen
<= (1 << PSEUDOVECTOR_REST_BITS
) - 1);
950 eassert (lisplen
<= (1 << PSEUDOVECTOR_SIZE_BITS
) - 1);
952 /* Only the first lisplen slots will be traced normally by the GC. */
953 for (i
= 0; i
< lisplen
; ++i
)
954 v
->contents
[i
] = Qnil
;
956 XSETPVECTYPESIZE (v
, tag
, lisplen
, memlen
- lisplen
);
961 allocate_buffer (void)
963 struct buffer
*b
= xmalloc (sizeof *b
);
965 BUFFER_PVEC_INIT (b
);
966 /* Put B on the chain of all buffers including killed ones. */
967 b
->next
= all_buffers
;
969 /* Note that the rest fields of B are not initialized. */
973 struct Lisp_Hash_Table
*
974 allocate_hash_table (void)
976 return ALLOCATE_PSEUDOVECTOR (struct Lisp_Hash_Table
, count
, PVEC_HASH_TABLE
);
980 allocate_window (void)
984 w
= ALLOCATE_PSEUDOVECTOR (struct window
, current_matrix
, PVEC_WINDOW
);
985 /* Users assumes that non-Lisp data is zeroed. */
986 memset (&w
->current_matrix
, 0,
987 sizeof (*w
) - offsetof (struct window
, current_matrix
));
992 allocate_terminal (void)
996 t
= ALLOCATE_PSEUDOVECTOR (struct terminal
, next_terminal
, PVEC_TERMINAL
);
997 /* Users assumes that non-Lisp data is zeroed. */
998 memset (&t
->next_terminal
, 0,
999 sizeof (*t
) - offsetof (struct terminal
, next_terminal
));
1004 allocate_frame (void)
1008 f
= ALLOCATE_PSEUDOVECTOR (struct frame
, face_cache
, PVEC_FRAME
);
1009 /* Users assumes that non-Lisp data is zeroed. */
1010 memset (&f
->face_cache
, 0,
1011 sizeof (*f
) - offsetof (struct frame
, face_cache
));
1015 struct Lisp_Process
*
1016 allocate_process (void)
1018 struct Lisp_Process
*p
;
1020 p
= ALLOCATE_PSEUDOVECTOR (struct Lisp_Process
, pid
, PVEC_PROCESS
);
1021 /* Users assumes that non-Lisp data is zeroed. */
1023 sizeof (*p
) - offsetof (struct Lisp_Process
, pid
));
1027 DEFUN ("make-vector", Fmake_vector
, Smake_vector
, 2, 2, 0,
1028 doc
: /* Return a newly created vector of length LENGTH, with each element being INIT.
1029 See also the function `vector'. */)
1030 (register Lisp_Object length
, Lisp_Object init
)
1033 register ptrdiff_t sizei
;
1034 register ptrdiff_t i
;
1035 register struct Lisp_Vector
*p
;
1037 CHECK_NATNUM (length
);
1039 p
= allocate_vector (XFASTINT (length
));
1040 sizei
= XFASTINT (length
);
1041 for (i
= 0; i
< sizei
; i
++)
1042 p
->contents
[i
] = init
;
1044 XSETVECTOR (vector
, p
);
1049 DEFUN ("vector", Fvector
, Svector
, 0, MANY
, 0,
1050 doc
: /* Return a newly created vector with specified arguments as elements.
1051 Any number of arguments, even zero arguments, are allowed.
1052 usage: (vector &rest OBJECTS) */)
1053 (ptrdiff_t nargs
, Lisp_Object
*args
)
1056 register Lisp_Object val
= make_uninit_vector (nargs
);
1057 register struct Lisp_Vector
*p
= XVECTOR (val
);
1059 for (i
= 0; i
< nargs
; i
++)
1060 p
->contents
[i
] = args
[i
];
1065 make_byte_code (struct Lisp_Vector
*v
)
1067 /* Don't allow the global zero_vector to become a byte code object. */
1068 eassert (0 < v
->header
.size
);
1070 if (v
->header
.size
> 1 && STRINGP (v
->contents
[1])
1071 && STRING_MULTIBYTE (v
->contents
[1]))
1072 /* BYTECODE-STRING must have been produced by Emacs 20.2 or the
1073 earlier because they produced a raw 8-bit string for byte-code
1074 and now such a byte-code string is loaded as multibyte while
1075 raw 8-bit characters converted to multibyte form. Thus, now we
1076 must convert them back to the original unibyte form. */
1077 v
->contents
[1] = Fstring_as_unibyte (v
->contents
[1]);
1078 XSETPVECTYPE (v
, PVEC_COMPILED
);
1081 DEFUN ("make-byte-code", Fmake_byte_code
, Smake_byte_code
, 4, MANY
, 0,
1082 doc
: /* Create a byte-code object with specified arguments as elements.
1083 The arguments should be the ARGLIST, bytecode-string BYTE-CODE, constant
1084 vector CONSTANTS, maximum stack size DEPTH, (optional) DOCSTRING,
1085 and (optional) INTERACTIVE-SPEC.
1086 The first four arguments are required; at most six have any
1088 The ARGLIST can be either like the one of `lambda', in which case the arguments
1089 will be dynamically bound before executing the byte code, or it can be an
1090 integer of the form NNNNNNNRMMMMMMM where the 7bit MMMMMMM specifies the
1091 minimum number of arguments, the 7-bit NNNNNNN specifies the maximum number
1092 of arguments (ignoring &rest) and the R bit specifies whether there is a &rest
1093 argument to catch the left-over arguments. If such an integer is used, the
1094 arguments will not be dynamically bound but will be instead pushed on the
1095 stack before executing the byte-code.
1096 usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS) */)
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 /* We used to purecopy everything here, if purify-flag was set. This worked
1104 OK for Emacs-23, but with Emacs-24's lexical binding code, it can be
1105 dangerous, since make-byte-code is used during execution to build
1106 closures, so any closure built during the preload phase would end up
1107 copied into pure space, including its free variables, which is sometimes
1108 just wasteful and other times plainly wrong (e.g. those free vars may want
1111 for (i
= 0; i
< nargs
; i
++)
1112 p
->contents
[i
] = args
[i
];
1114 XSETCOMPILED (val
, p
);
1120 /***********************************************************************
1122 ***********************************************************************/
1125 set_symbol_name (Lisp_Object sym
, Lisp_Object name
)
1127 XSYMBOL (sym
)->name
= name
;
1130 DEFUN ("make-symbol", Fmake_symbol
, Smake_symbol
, 1, 1, 0,
1131 doc
: /* Return a newly allocated uninterned symbol whose name is NAME.
1132 Its value is void, and its function definition and property list are nil. */)
1135 register Lisp_Object val
;
1136 register struct Lisp_Symbol
*p
;
1138 CHECK_STRING (name
);
1140 XSETSYMBOL (val
, xmalloc (sizeof (struct Lisp_Symbol
)));
1142 set_symbol_name (val
, name
);
1143 set_symbol_plist (val
, Qnil
);
1144 p
->redirect
= SYMBOL_PLAINVAL
;
1145 SET_SYMBOL_VAL (p
, Qunbound
);
1146 set_symbol_function (val
, Qnil
);
1147 set_symbol_next (val
, NULL
);
1148 p
->gcmarkbit
= false;
1149 p
->interned
= SYMBOL_UNINTERNED
;
1151 p
->declared_special
= false;
1158 /***********************************************************************
1159 Marker (Misc) Allocation
1160 ***********************************************************************/
1162 /* Return a newly allocated Lisp_Misc object of specified TYPE. */
1165 allocate_misc (enum Lisp_Misc_Type type
)
1169 XSETMISC (val
, xmalloc (sizeof (union Lisp_Misc
)));
1170 XMISCANY (val
)->type
= type
;
1174 /* Free a Lisp_Misc object. */
1177 free_misc (Lisp_Object misc
)
1182 /* Verify properties of Lisp_Save_Value's representation
1183 that are assumed here and elsewhere. */
1185 verify (SAVE_UNUSED
== 0);
1186 verify (((SAVE_INTEGER
| SAVE_POINTER
| SAVE_FUNCPOINTER
| SAVE_OBJECT
)
1190 /* Return Lisp_Save_Value objects for the various combinations
1191 that callers need. */
1194 make_save_int_int_int (ptrdiff_t a
, ptrdiff_t b
, ptrdiff_t c
)
1196 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1197 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1198 p
->save_type
= SAVE_TYPE_INT_INT_INT
;
1199 p
->data
[0].integer
= a
;
1200 p
->data
[1].integer
= b
;
1201 p
->data
[2].integer
= c
;
1206 make_save_obj_obj_obj_obj (Lisp_Object a
, Lisp_Object b
, Lisp_Object c
,
1209 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1210 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1211 p
->save_type
= SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
;
1212 p
->data
[0].object
= a
;
1213 p
->data
[1].object
= b
;
1214 p
->data
[2].object
= c
;
1215 p
->data
[3].object
= d
;
1220 make_save_ptr (void *a
)
1222 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1223 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1224 p
->save_type
= SAVE_POINTER
;
1225 p
->data
[0].pointer
= a
;
1230 make_save_ptr_int (void *a
, ptrdiff_t b
)
1232 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1233 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1234 p
->save_type
= SAVE_TYPE_PTR_INT
;
1235 p
->data
[0].pointer
= a
;
1236 p
->data
[1].integer
= b
;
1240 #if ! (defined USE_X_TOOLKIT || defined USE_GTK)
1242 make_save_ptr_ptr (void *a
, void *b
)
1244 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1245 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1246 p
->save_type
= SAVE_TYPE_PTR_PTR
;
1247 p
->data
[0].pointer
= a
;
1248 p
->data
[1].pointer
= b
;
1254 make_save_funcptr_ptr_obj (void (*a
) (void), void *b
, Lisp_Object c
)
1256 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1257 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1258 p
->save_type
= SAVE_TYPE_FUNCPTR_PTR_OBJ
;
1259 p
->data
[0].funcpointer
= a
;
1260 p
->data
[1].pointer
= b
;
1261 p
->data
[2].object
= c
;
1265 /* Return a Lisp_Save_Value object that represents an array A
1266 of N Lisp objects. */
1269 make_save_memory (Lisp_Object
*a
, ptrdiff_t n
)
1271 Lisp_Object val
= allocate_misc (Lisp_Misc_Save_Value
);
1272 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
1273 p
->save_type
= SAVE_TYPE_MEMORY
;
1274 p
->data
[0].pointer
= a
;
1275 p
->data
[1].integer
= n
;
1279 /* Free a Lisp_Save_Value object. Do not use this function
1280 if SAVE contains pointer other than returned by xmalloc. */
1283 free_save_value (Lisp_Object save
)
1285 xfree (XSAVE_POINTER (save
, 0));
1289 /* Return a Lisp_Misc_Overlay object with specified START, END and PLIST. */
1292 build_overlay (Lisp_Object start
, Lisp_Object end
, Lisp_Object plist
)
1294 register Lisp_Object overlay
;
1296 overlay
= allocate_misc (Lisp_Misc_Overlay
);
1297 OVERLAY_START (overlay
) = start
;
1298 OVERLAY_END (overlay
) = end
;
1299 set_overlay_plist (overlay
, plist
);
1300 XOVERLAY (overlay
)->next
= NULL
;
1304 DEFUN ("make-marker", Fmake_marker
, Smake_marker
, 0, 0, 0,
1305 doc
: /* Return a newly allocated marker which does not point at any place. */)
1308 register Lisp_Object val
;
1309 register struct Lisp_Marker
*p
;
1311 val
= allocate_misc (Lisp_Misc_Marker
);
1317 p
->insertion_type
= 0;
1318 p
->need_adjustment
= 0;
1322 /* Return a newly allocated marker which points into BUF
1323 at character position CHARPOS and byte position BYTEPOS. */
1326 build_marker (struct buffer
*buf
, ptrdiff_t charpos
, ptrdiff_t bytepos
)
1329 struct Lisp_Marker
*m
;
1331 /* No dead buffers here. */
1332 eassert (BUFFER_LIVE_P (buf
));
1334 /* Every character is at least one byte. */
1335 eassert (charpos
<= bytepos
);
1337 obj
= allocate_misc (Lisp_Misc_Marker
);
1340 m
->charpos
= charpos
;
1341 m
->bytepos
= bytepos
;
1342 m
->insertion_type
= 0;
1343 m
->need_adjustment
= 0;
1344 m
->next
= BUF_MARKERS (buf
);
1345 BUF_MARKERS (buf
) = m
;
1349 /* Return a newly created vector or string with specified arguments as
1350 elements. If all the arguments are characters that can fit
1351 in a string of events, make a string; otherwise, make a vector.
1353 Any number of arguments, even zero arguments, are allowed. */
1356 make_event_array (ptrdiff_t nargs
, Lisp_Object
*args
)
1360 for (i
= 0; i
< nargs
; i
++)
1361 /* The things that fit in a string
1362 are characters that are in 0...127,
1363 after discarding the meta bit and all the bits above it. */
1364 if (!INTEGERP (args
[i
])
1365 || (XINT (args
[i
]) & ~(-CHAR_META
)) >= 0200)
1366 return Fvector (nargs
, args
);
1368 /* Since the loop exited, we know that all the things in it are
1369 characters, so we can make a string. */
1373 result
= Fmake_string (make_number (nargs
), make_number (0));
1374 for (i
= 0; i
< nargs
; i
++)
1376 SSET (result
, i
, XINT (args
[i
]));
1377 /* Move the meta bit to the right place for a string char. */
1378 if (XINT (args
[i
]) & CHAR_META
)
1379 SSET (result
, i
, SREF (result
, i
) | 0x80);
1388 /************************************************************************
1389 Memory Full Handling
1390 ************************************************************************/
1393 /* Called if xmalloc (NBYTES) returns zero. If NBYTES == SIZE_MAX,
1394 there may have been size_t overflow so that xmalloc was never
1395 called, or perhaps xmalloc was invoked successfully but the
1396 resulting pointer had problems fitting into a tagged EMACS_INT. In
1397 either case this counts as memory being full even though xmalloc
1401 memory_full (size_t nbytes
)
1403 /* Do not go into hysterics merely because a large request failed. */
1404 bool enough_free_memory
= 0;
1405 if (SPARE_MEMORY
< nbytes
)
1407 void *p
= GC_MALLOC (SPARE_MEMORY
);
1411 enough_free_memory
= 1;
1415 if (! enough_free_memory
)
1419 /* The first time we get here, free the spare memory. */
1422 xfree (spare_memory
);
1423 spare_memory
= NULL
;
1427 /* This used to call error, but if we've run out of memory, we could
1428 get infinite recursion trying to build the string. */
1429 xsignal (Qnil
, Vmemory_signal_data
);
1432 /* If we released our reserve (due to running out of memory),
1433 and we have a fair amount free once again,
1434 try to set aside another reserve in case we run out once more.
1436 This is called when a relocatable block is freed in ralloc.c,
1437 and also directly from this file, in case we're not using ralloc.c. */
1440 refill_memory_reserve (void)
1442 if (spare_memory
== NULL
)
1443 spare_memory
= GC_MALLOC (SPARE_MEMORY
);
1446 Vmemory_full
= Qnil
;
1449 /* Determine whether it is safe to access memory at address P. */
1451 valid_pointer_p (void *p
)
1454 return w32_valid_pointer_p (p
, 16);
1458 /* Obviously, we cannot just access it (we would SEGV trying), so we
1459 trick the o/s to tell us whether p is a valid pointer.
1460 Unfortunately, we cannot use NULL_DEVICE here, as emacs_write may
1461 not validate p in that case. */
1463 if (emacs_pipe (fd
) == 0)
1465 bool valid
= emacs_write (fd
[1], p
, 16) == 16;
1466 emacs_close (fd
[1]);
1467 emacs_close (fd
[0]);
1475 /* Return 2 if OBJ is a killed or special buffer object, 1 if OBJ is a
1476 valid lisp object, 0 if OBJ is NOT a valid lisp object, or -1 if we
1477 cannot validate OBJ. This function can be quite slow, so its primary
1478 use is the manual debugging. The only exception is print_object, where
1479 we use it to check whether the memory referenced by the pointer of
1480 Lisp_Save_Value object contains valid objects. */
1483 valid_lisp_object_p (Lisp_Object obj
)
1490 p
= (void *) XPNTR (obj
);
1492 if (p
== &buffer_defaults
|| p
== &buffer_local_symbols
)
1495 return valid_pointer_p (p
);
1498 /* If GC_MARK_STACK, return 1 if STR is a relocatable data of Lisp_String
1499 (i.e. there is a non-pure Lisp_Object X so that SDATA (X) == STR) and 0
1500 if not. Otherwise we can't rely on valid_lisp_object_p and return -1.
1501 This function is slow and should be used for debugging purposes. */
1504 relocatable_string_data_p (const char *str
)
1509 /***********************************************************************
1510 Pure Storage Compatibility Functions
1511 ***********************************************************************/
1514 check_pure_size (void)
1520 make_pure_string (const char *data
,
1521 ptrdiff_t nchars
, ptrdiff_t nbytes
, bool multibyte
)
1523 return make_specified_string (data
, nchars
, nbytes
, multibyte
);
1527 make_pure_c_string (const char *data
, ptrdiff_t nchars
)
1529 return build_string (data
);
1533 pure_cons (Lisp_Object car
, Lisp_Object cdr
)
1535 return Fcons (car
, cdr
);
1538 DEFUN ("purecopy", Fpurecopy
, Spurecopy
, 1, 1, 0,
1539 doc
: /* Return OBJ. */)
1540 (register Lisp_Object obj
)
1545 /***********************************************************************
1547 ***********************************************************************/
1550 staticpro (Lisp_Object
*varaddress
)
1555 DEFUN ("garbage-collect", Fgarbage_collect
, Sgarbage_collect
, 0, 0, "",
1556 doc
: /* Reclaim storage for Lisp objects no longer needed.
1557 Garbage collection happens automatically if you cons more than
1558 `gc-cons-threshold' bytes of Lisp data since previous garbage collection.
1559 `garbage-collect' normally returns a list with info on amount of space in use,
1560 where each entry has the form (NAME SIZE USED FREE), where:
1561 - NAME is a symbol describing the kind of objects this entry represents,
1562 - SIZE is the number of bytes used by each one,
1563 - USED is the number of those objects that were found live in the heap,
1564 - FREE is the number of those objects that are not live but that Emacs
1565 keeps around for future allocations (maybe because it does not know how
1566 to return them to the OS).
1567 However, if there was overflow in pure space, `garbage-collect'
1568 returns nil, because real GC can't be done.
1569 See Info node `(elisp)Garbage Collection'. */)
1576 #ifdef ENABLE_CHECKING
1578 bool suppress_checking
;
1581 die (const char *msg
, const char *file
, int line
)
1583 fprintf (stderr
, "\r\n%s:%d: Emacs fatal error: assertion failed: %s\r\n",
1585 terminate_due_to_signal (SIGABRT
, INT_MAX
);
1589 /* Initialization. */
1592 init_alloc_once (void)
1594 /* Used to do Vpurify_flag = Qt here, but Qt isn't set up yet! */
1599 refill_memory_reserve ();
1600 gc_cons_threshold
= GC_DEFAULT_THRESHOLD
;
1607 Vgc_elapsed
= make_float (0.0);
1611 valgrind_p
= RUNNING_ON_VALGRIND
!= 0;
1616 syms_of_alloc (void)
1618 DEFVAR_INT ("gc-cons-threshold", gc_cons_threshold
,
1619 doc
: /* Number of bytes of consing between garbage collections.
1620 Garbage collection can happen automatically once this many bytes have been
1621 allocated since the last garbage collection. All data types count.
1623 Garbage collection happens automatically only when `eval' is called.
1625 By binding this temporarily to a large number, you can effectively
1626 prevent garbage collection during a part of the program.
1627 See also `gc-cons-percentage'. */);
1629 DEFVAR_LISP ("gc-cons-percentage", Vgc_cons_percentage
,
1630 doc
: /* Portion of the heap used for allocation.
1631 Garbage collection can happen automatically once this portion of the heap
1632 has been allocated since the last garbage collection.
1633 If this portion is smaller than `gc-cons-threshold', this is ignored. */);
1634 Vgc_cons_percentage
= make_float (0.1);
1636 DEFVAR_INT ("pure-bytes-used", pure_bytes_used
,
1637 doc
: /* Number of bytes of shareable Lisp data allocated so far. */);
1639 DEFVAR_LISP ("purify-flag", Vpurify_flag
,
1640 doc
: /* Non-nil means loading Lisp code in order to dump an executable.
1641 This means that certain objects should be allocated in shared (pure) space.
1642 It can also be set to a hash-table, in which case this table is used to
1643 do hash-consing of the objects allocated to pure space. */);
1645 DEFVAR_BOOL ("garbage-collection-messages", garbage_collection_messages
,
1646 doc
: /* Non-nil means display messages at start and end of garbage collection. */);
1647 garbage_collection_messages
= 0;
1649 DEFVAR_LISP ("post-gc-hook", Vpost_gc_hook
,
1650 doc
: /* Hook run after garbage collection has finished. */);
1651 Vpost_gc_hook
= Qnil
;
1652 DEFSYM (Qpost_gc_hook
, "post-gc-hook");
1654 DEFVAR_LISP ("memory-signal-data", Vmemory_signal_data
,
1655 doc
: /* Precomputed `signal' argument for memory-full error. */);
1656 /* We build this in advance because if we wait until we need it, we might
1657 not be able to allocate the memory to hold it. */
1659 = listn (CONSTYPE_PURE
, 2, Qerror
,
1660 build_pure_c_string ("Memory exhausted--use M-x save-some-buffers then exit and restart Emacs"));
1662 DEFVAR_LISP ("memory-full", Vmemory_full
,
1663 doc
: /* Non-nil means Emacs cannot get much more Lisp memory. */);
1664 Vmemory_full
= Qnil
;
1666 DEFSYM (Qgc_cons_threshold
, "gc-cons-threshold");
1667 DEFSYM (Qchar_table_extra_slots
, "char-table-extra-slots");
1669 DEFVAR_LISP ("gc-elapsed", Vgc_elapsed
,
1670 doc
: /* Accumulated time elapsed in garbage collections.
1671 The time is in seconds as a floating point value. */);
1672 DEFVAR_INT ("gcs-done", gcs_done
,
1673 doc
: /* Accumulated number of garbage collections done. */);
1678 defsubr (&Sbool_vector
);
1679 defsubr (&Smake_byte_code
);
1680 defsubr (&Smake_list
);
1681 defsubr (&Smake_vector
);
1682 defsubr (&Smake_string
);
1683 defsubr (&Smake_bool_vector
);
1684 defsubr (&Smake_symbol
);
1685 defsubr (&Smake_marker
);
1686 defsubr (&Spurecopy
);
1687 defsubr (&Sgarbage_collect
);
1690 /* When compiled with GCC, GDB might say "No enum type named
1691 pvec_type" if we don't have at least one symbol with that type, and
1692 then xbacktrace could fail. Similarly for the other enums and
1693 their values. Some non-GCC compilers don't like these constructs. */
1697 enum CHARTAB_SIZE_BITS CHARTAB_SIZE_BITS
;
1698 enum CHAR_TABLE_STANDARD_SLOTS CHAR_TABLE_STANDARD_SLOTS
;
1699 enum char_bits char_bits
;
1700 enum CHECK_LISP_OBJECT_TYPE CHECK_LISP_OBJECT_TYPE
;
1701 enum DEFAULT_HASH_SIZE DEFAULT_HASH_SIZE
;
1702 enum Lisp_Bits Lisp_Bits
;
1703 enum Lisp_Compiled Lisp_Compiled
;
1704 enum maxargs maxargs
;
1705 enum MAX_ALLOCA MAX_ALLOCA
;
1706 enum More_Lisp_Bits More_Lisp_Bits
;
1707 enum pvec_type pvec_type
;
1708 } const EXTERNALLY_VISIBLE gdb_make_enums_visible
= {0};
1709 #endif /* __GNUC__ */