Remove unused XMALLOC_BLOCK_INPUT_CHECK debug facility
The compile-time option XMALLOC_BLOCK_INPUT_CHECK was added in
2012 (commit 4d7e6e51dd) to allow blocking input during
malloc-family calls, in case any issues arose from related
changes in Emacs 24.3. However, it has not been referenced on
emacs-devel or the bug tracker in over a decade.
It is clear that we do not need it, as our signal handlers do not
allocate memory. Removing it simplifies the allocation function
wrappers and eliminates dead debug code.
Ref: https://debbugs.gnu.org/12450
* src/alloc.c [XMALLOC_BLOCK_INPUT_CHECK]
(malloc_block_input, malloc_unblock_input): Delete functions.
(MALLOC_BLOCK_INPUT, MALLOC_UNBLOCK_INPUT): Delete macros. Update
all callers.
This commit is contained in:
Stefan Kangas
parent
74df372398
commit
a7f5d183a8
1 changed files with 6 additions and 105 deletions
111
src/alloc.c
111
src/alloc.c
|
|
@ -635,39 +635,6 @@ static_assert (LISP_ALIGNMENT % GCALIGNMENT == 0);
|
|||
enum { MALLOC_IS_LISP_ALIGNED = alignof (max_align_t) % LISP_ALIGNMENT == 0 };
|
||||
static_assert (MALLOC_IS_LISP_ALIGNED);
|
||||
|
||||
/* If compiled with XMALLOC_BLOCK_INPUT_CHECK, define a symbol
|
||||
BLOCK_INPUT_IN_MEMORY_ALLOCATORS that is visible to the debugger.
|
||||
If that variable is set, block input while in one of Emacs's memory
|
||||
allocation functions. There should be no need for this debugging
|
||||
option, since signal handlers do not allocate memory, but Emacs
|
||||
formerly allocated memory in signal handlers and this compile-time
|
||||
option remains as a way to help debug the issue should it rear its
|
||||
ugly head again. */
|
||||
#ifdef XMALLOC_BLOCK_INPUT_CHECK
|
||||
bool block_input_in_memory_allocators EXTERNALLY_VISIBLE;
|
||||
static void
|
||||
malloc_block_input (void)
|
||||
{
|
||||
if (block_input_in_memory_allocators)
|
||||
block_input ();
|
||||
}
|
||||
static void
|
||||
malloc_unblock_input (void)
|
||||
{
|
||||
if (block_input_in_memory_allocators)
|
||||
{
|
||||
int err = errno;
|
||||
unblock_input ();
|
||||
errno = err;
|
||||
}
|
||||
}
|
||||
# define MALLOC_BLOCK_INPUT malloc_block_input ()
|
||||
# define MALLOC_UNBLOCK_INPUT malloc_unblock_input ()
|
||||
#else
|
||||
# define MALLOC_BLOCK_INPUT ((void) 0)
|
||||
# define MALLOC_UNBLOCK_INPUT ((void) 0)
|
||||
#endif
|
||||
|
||||
#define MALLOC_PROBE(size) \
|
||||
do { \
|
||||
if (profiler_memory_running) \
|
||||
|
|
@ -679,12 +646,7 @@ malloc_unblock_input (void)
|
|||
void *
|
||||
xmalloc (size_t size)
|
||||
{
|
||||
void *val;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
val = malloc (size);
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
void *val = malloc (size);
|
||||
if (!val)
|
||||
memory_full (size);
|
||||
MALLOC_PROBE (size);
|
||||
|
|
@ -696,12 +658,7 @@ xmalloc (size_t size)
|
|||
void *
|
||||
xzalloc (size_t size)
|
||||
{
|
||||
void *val;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
val = calloc (1, size);
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
void *val = calloc (1, size);
|
||||
if (!val)
|
||||
memory_full (size);
|
||||
MALLOC_PROBE (size);
|
||||
|
|
@ -713,12 +670,7 @@ xzalloc (size_t size)
|
|||
void *
|
||||
xrealloc (void *block, size_t size)
|
||||
{
|
||||
void *val;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
val = realloc (block, size);
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
void *val = realloc (block, size);
|
||||
if (!val)
|
||||
memory_full (size);
|
||||
MALLOC_PROBE (size);
|
||||
|
|
@ -735,9 +687,7 @@ xfree (void *block)
|
|||
return;
|
||||
if (pdumper_object_p (block))
|
||||
return;
|
||||
MALLOC_BLOCK_INPUT;
|
||||
free (block);
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
/* We don't call refill_memory_reserve here
|
||||
because in practice the call in r_alloc_free seems to suffice. */
|
||||
}
|
||||
|
|
@ -922,15 +872,11 @@ void *lisp_malloc_loser EXTERNALLY_VISIBLE;
|
|||
static void *
|
||||
lisp_malloc (size_t nbytes, bool clearit, enum mem_type type)
|
||||
{
|
||||
register void *val;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
|
||||
#ifdef GC_MALLOC_CHECK
|
||||
allocated_mem_type = type;
|
||||
#endif
|
||||
|
||||
val = clearit ? calloc (1, nbytes) : malloc (nbytes);
|
||||
void *val = clearit ? calloc (1, nbytes) : malloc (nbytes);
|
||||
|
||||
#if ! USE_LSB_TAG
|
||||
/* If the memory just allocated cannot be addressed thru a Lisp
|
||||
|
|
@ -954,7 +900,6 @@ lisp_malloc (size_t nbytes, bool clearit, enum mem_type type)
|
|||
mem_insert (val, (char *) val + nbytes, type);
|
||||
#endif
|
||||
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
if (!val)
|
||||
memory_full (nbytes);
|
||||
MALLOC_PROBE (nbytes);
|
||||
|
|
@ -970,7 +915,6 @@ lisp_free (void *block)
|
|||
if (pdumper_object_p (block))
|
||||
return;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
#ifndef GC_MALLOC_CHECK
|
||||
struct mem_node *m = mem_find (block);
|
||||
#endif
|
||||
|
|
@ -978,7 +922,6 @@ lisp_free (void *block)
|
|||
#ifndef GC_MALLOC_CHECK
|
||||
mem_delete (m);
|
||||
#endif
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
}
|
||||
|
||||
/***** Allocation of aligned blocks of memory to store Lisp data. *****/
|
||||
|
|
@ -1116,8 +1059,6 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
|
|||
|
||||
eassert (nbytes <= BLOCK_BYTES);
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
|
||||
#ifdef GC_MALLOC_CHECK
|
||||
allocated_mem_type = type;
|
||||
#endif
|
||||
|
|
@ -1141,10 +1082,7 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
|
|||
#endif
|
||||
|
||||
if (base == 0)
|
||||
{
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
memory_full (ABLOCKS_BYTES);
|
||||
}
|
||||
memory_full (ABLOCKS_BYTES);
|
||||
|
||||
aligned = (base == abase);
|
||||
if (!aligned)
|
||||
|
|
@ -1168,7 +1106,6 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
|
|||
{
|
||||
lisp_malloc_loser = base;
|
||||
free (base);
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
memory_full (SIZE_MAX);
|
||||
}
|
||||
}
|
||||
|
|
@ -1205,8 +1142,6 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
|
|||
mem_insert (val, (char *) val + nbytes, type);
|
||||
#endif
|
||||
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
MALLOC_PROBE (nbytes);
|
||||
|
||||
eassert (0 == ((uintptr_t) val) % BLOCK_ALIGN);
|
||||
|
|
@ -1219,7 +1154,6 @@ lisp_align_free (void *block)
|
|||
struct ablock *ablock = block;
|
||||
struct ablocks *abase = ABLOCK_ABASE (ablock);
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
#ifndef GC_MALLOC_CHECK
|
||||
mem_delete (mem_find (block));
|
||||
#endif
|
||||
|
|
@ -1259,7 +1193,6 @@ lisp_align_free (void *block)
|
|||
#endif
|
||||
free (ABLOCKS_BASE (abase));
|
||||
}
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1322,8 +1255,6 @@ make_interval (void)
|
|||
{
|
||||
INTERVAL val;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
|
||||
if (interval_free_list)
|
||||
{
|
||||
val = interval_free_list;
|
||||
|
|
@ -1346,8 +1277,6 @@ make_interval (void)
|
|||
ASAN_UNPOISON_INTERVAL (val);
|
||||
}
|
||||
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
tally_consing (sizeof (struct interval));
|
||||
intervals_consed++;
|
||||
RESET_INTERVAL (val);
|
||||
|
|
@ -1735,8 +1664,6 @@ allocate_string (void)
|
|||
{
|
||||
struct Lisp_String *s;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
|
||||
/* If the free-list is empty, allocate a new string_block, and
|
||||
add all the Lisp_Strings in it to the free-list. */
|
||||
if (string_free_list == NULL)
|
||||
|
|
@ -1765,8 +1692,6 @@ allocate_string (void)
|
|||
ASAN_UNPOISON_STRING (s);
|
||||
string_free_list = NEXT_FREE_LISP_STRING (s);
|
||||
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
++strings_consed;
|
||||
tally_consing (sizeof *s);
|
||||
|
||||
|
|
@ -1810,8 +1735,6 @@ allocate_string_data (struct Lisp_String *s,
|
|||
of string data. */
|
||||
ptrdiff_t needed = sdata_size (nbytes);
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
|
||||
if (nbytes > LARGE_STRING_BYTES || immovable)
|
||||
{
|
||||
size_t size = FLEXSIZEOF (struct sblock, data, needed);
|
||||
|
|
@ -1875,8 +1798,6 @@ allocate_string_data (struct Lisp_String *s,
|
|||
b->next_free = (sdata *) ((char *) data + needed + GC_STRING_EXTRA);
|
||||
eassert ((uintptr_t) b->next_free % alignof (sdata) == 0);
|
||||
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
s->u.s.data = SDATA_DATA (data);
|
||||
#ifdef GC_CHECK_STRING_BYTES
|
||||
SDATA_NBYTES (data) = nbytes;
|
||||
|
|
@ -2606,8 +2527,6 @@ make_float (double float_value)
|
|||
{
|
||||
register Lisp_Object val;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
|
||||
if (float_free_list)
|
||||
{
|
||||
XSETFLOAT (val, float_free_list);
|
||||
|
|
@ -2631,8 +2550,6 @@ make_float (double float_value)
|
|||
float_block_index++;
|
||||
}
|
||||
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
XFLOAT_INIT (val, float_value);
|
||||
eassert (!XFLOAT_MARKED_P (XFLOAT (val)));
|
||||
tally_consing (sizeof (struct Lisp_Float));
|
||||
|
|
@ -2730,8 +2647,6 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
|
|||
{
|
||||
register Lisp_Object val;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
|
||||
if (cons_free_list)
|
||||
{
|
||||
ASAN_UNPOISON_CONS (cons_free_list);
|
||||
|
|
@ -2755,8 +2670,6 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
|
|||
cons_block_index++;
|
||||
}
|
||||
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
XSETCAR (val, car);
|
||||
XSETCDR (val, cdr);
|
||||
eassert (!XCONS_MARKED_P (XCONS (val)));
|
||||
|
|
@ -3488,8 +3401,6 @@ allocate_vectorlike (ptrdiff_t len, bool clearit)
|
|||
ptrdiff_t nbytes = header_size + len * word_size;
|
||||
struct Lisp_Vector *p;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
|
||||
#ifdef DOUG_LEA_MALLOC
|
||||
if (!mmap_lisp_allowed_p ())
|
||||
mallopt (M_MMAP_MAX, 0);
|
||||
|
|
@ -3518,8 +3429,6 @@ allocate_vectorlike (ptrdiff_t len, bool clearit)
|
|||
tally_consing (nbytes);
|
||||
vector_cells_consed += len;
|
||||
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
|
|
@ -3817,8 +3726,6 @@ Its value is void, and its function definition and property list are nil. */)
|
|||
|
||||
CHECK_STRING (name);
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
|
||||
if (symbol_free_list)
|
||||
{
|
||||
ASAN_UNPOISON_SYMBOL (symbol_free_list);
|
||||
|
|
@ -3842,8 +3749,6 @@ Its value is void, and its function definition and property list are nil. */)
|
|||
symbol_block_index++;
|
||||
}
|
||||
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
|
||||
init_symbol (val, name);
|
||||
tally_consing (sizeof (struct Lisp_Symbol));
|
||||
symbols_consed++;
|
||||
|
|
@ -4250,16 +4155,12 @@ memory_full (size_t nbytes)
|
|||
bool enough_free_memory = false;
|
||||
if (SPARE_MEMORY < nbytes)
|
||||
{
|
||||
void *p;
|
||||
|
||||
MALLOC_BLOCK_INPUT;
|
||||
p = malloc (SPARE_MEMORY);
|
||||
void *p = malloc (SPARE_MEMORY);
|
||||
if (p)
|
||||
{
|
||||
free (p);
|
||||
enough_free_memory = true;
|
||||
}
|
||||
MALLOC_UNBLOCK_INPUT;
|
||||
}
|
||||
|
||||
if (! enough_free_memory)
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue