mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2025-12-06 06:20:55 -08:00
Code Issues Projects Releases Wiki Activity

Remove unused XMALLOC_BLOCK_INPUT_CHECK debug facility

Browse source 
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 2025-04-14 20:40:49 +02:00
parent 74df372398
commit a7f5d183a8
1 changed files with 6 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

109
src/alloc.c
View file

@ -635,39 +635,6 @@ static_assert (LISP_ALIGNMENT % GCALIGNMENT == 0);
enum { MALLOC_IS_LISP_ALIGNED = alignof (max_align_t) % LISP_ALIGNMENT == 0 }; enum { MALLOC_IS_LISP_ALIGNED = alignof (max_align_t) % LISP_ALIGNMENT == 0 };
static_assert (MALLOC_IS_LISP_ALIGNED); 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) \ #define MALLOC_PROBE(size) \
do { \ do { \
if (profiler_memory_running) \ if (profiler_memory_running) \
@ -679,12 +646,7 @@ malloc_unblock_input (void)
void * void *
xmalloc (size_t size) xmalloc (size_t size)
{ {
void *val; void *val = malloc (size);
MALLOC_BLOCK_INPUT;
val = malloc (size);
MALLOC_UNBLOCK_INPUT;
if (!val) if (!val)
memory_full (size); memory_full (size);
MALLOC_PROBE (size); MALLOC_PROBE (size);
@ -696,12 +658,7 @@ xmalloc (size_t size)
void * void *
xzalloc (size_t size) xzalloc (size_t size)
{ {
void *val; void *val = calloc (1, size);
MALLOC_BLOCK_INPUT;
val = calloc (1, size);
MALLOC_UNBLOCK_INPUT;
if (!val) if (!val)
memory_full (size); memory_full (size);
MALLOC_PROBE (size); MALLOC_PROBE (size);
@ -713,12 +670,7 @@ xzalloc (size_t size)
void * void *
xrealloc (void *block, size_t size) xrealloc (void *block, size_t size)
{ {
void *val; void *val = realloc (block, size);
MALLOC_BLOCK_INPUT;
val = realloc (block, size);
MALLOC_UNBLOCK_INPUT;
if (!val) if (!val)
memory_full (size); memory_full (size);
MALLOC_PROBE (size); MALLOC_PROBE (size);
@ -735,9 +687,7 @@ xfree (void *block)
return; return;
if (pdumper_object_p (block)) if (pdumper_object_p (block))
return; return;
MALLOC_BLOCK_INPUT;
free (block); free (block);
MALLOC_UNBLOCK_INPUT;
/* We don't call refill_memory_reserve here /* We don't call refill_memory_reserve here
because in practice the call in r_alloc_free seems to suffice. */ because in practice the call in r_alloc_free seems to suffice. */
} }
@ -922,15 +872,11 @@ void *lisp_malloc_loser EXTERNALLY_VISIBLE;
static void * static void *
lisp_malloc (size_t nbytes, bool clearit, enum mem_type type) lisp_malloc (size_t nbytes, bool clearit, enum mem_type type)
{ {
register void *val;
MALLOC_BLOCK_INPUT;
#ifdef GC_MALLOC_CHECK #ifdef GC_MALLOC_CHECK
allocated_mem_type = type; allocated_mem_type = type;
#endif #endif
val = clearit ? calloc (1, nbytes) : malloc (nbytes); void *val = clearit ? calloc (1, nbytes) : malloc (nbytes);
#if ! USE_LSB_TAG #if ! USE_LSB_TAG
/* If the memory just allocated cannot be addressed thru a Lisp /* 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); mem_insert (val, (char *) val + nbytes, type);
#endif #endif
MALLOC_UNBLOCK_INPUT;
if (!val) if (!val)
memory_full (nbytes); memory_full (nbytes);
MALLOC_PROBE (nbytes); MALLOC_PROBE (nbytes);
@ -970,7 +915,6 @@ lisp_free (void *block)
if (pdumper_object_p (block)) if (pdumper_object_p (block))
return; return;
MALLOC_BLOCK_INPUT;
#ifndef GC_MALLOC_CHECK #ifndef GC_MALLOC_CHECK
struct mem_node *m = mem_find (block); struct mem_node *m = mem_find (block);
#endif #endif
@ -978,7 +922,6 @@ lisp_free (void *block)
#ifndef GC_MALLOC_CHECK #ifndef GC_MALLOC_CHECK
mem_delete (m); mem_delete (m);
#endif #endif
MALLOC_UNBLOCK_INPUT;
} }
/***** Allocation of aligned blocks of memory to store Lisp data. *****/ /***** 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); eassert (nbytes <= BLOCK_BYTES);
MALLOC_BLOCK_INPUT;
#ifdef GC_MALLOC_CHECK #ifdef GC_MALLOC_CHECK
allocated_mem_type = type; allocated_mem_type = type;
#endif #endif
@ -1141,10 +1082,7 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
#endif #endif
if (base == 0) if (base == 0)
{
MALLOC_UNBLOCK_INPUT;
memory_full (ABLOCKS_BYTES); memory_full (ABLOCKS_BYTES);
}
aligned = (base == abase); aligned = (base == abase);
if (!aligned) if (!aligned)
@ -1168,7 +1106,6 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
{ {
lisp_malloc_loser = base; lisp_malloc_loser = base;
free (base); free (base);
MALLOC_UNBLOCK_INPUT;
memory_full (SIZE_MAX); 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); mem_insert (val, (char *) val + nbytes, type);
#endif #endif
MALLOC_UNBLOCK_INPUT;
MALLOC_PROBE (nbytes); MALLOC_PROBE (nbytes);
eassert (0 == ((uintptr_t) val) % BLOCK_ALIGN); eassert (0 == ((uintptr_t) val) % BLOCK_ALIGN);
@ -1219,7 +1154,6 @@ lisp_align_free (void *block)
struct ablock *ablock = block; struct ablock *ablock = block;
struct ablocks *abase = ABLOCK_ABASE (ablock); struct ablocks *abase = ABLOCK_ABASE (ablock);
MALLOC_BLOCK_INPUT;
#ifndef GC_MALLOC_CHECK #ifndef GC_MALLOC_CHECK
mem_delete (mem_find (block)); mem_delete (mem_find (block));
#endif #endif
@ -1259,7 +1193,6 @@ lisp_align_free (void *block)
#endif #endif
free (ABLOCKS_BASE (abase)); free (ABLOCKS_BASE (abase));
} }
MALLOC_UNBLOCK_INPUT;
} }
@ -1322,8 +1255,6 @@ make_interval (void)
{ {
INTERVAL val; INTERVAL val;
MALLOC_BLOCK_INPUT;
if (interval_free_list) if (interval_free_list)
{ {
val = interval_free_list; val = interval_free_list;
@ -1346,8 +1277,6 @@ make_interval (void)
ASAN_UNPOISON_INTERVAL (val); ASAN_UNPOISON_INTERVAL (val);
} }
MALLOC_UNBLOCK_INPUT;
tally_consing (sizeof (struct interval)); tally_consing (sizeof (struct interval));
intervals_consed++; intervals_consed++;
RESET_INTERVAL (val); RESET_INTERVAL (val);
@ -1735,8 +1664,6 @@ allocate_string (void)
{ {
struct Lisp_String *s; struct Lisp_String *s;
MALLOC_BLOCK_INPUT;
/* If the free-list is empty, allocate a new string_block, and /* If the free-list is empty, allocate a new string_block, and
add all the Lisp_Strings in it to the free-list. */ add all the Lisp_Strings in it to the free-list. */
if (string_free_list == NULL) if (string_free_list == NULL)
@ -1765,8 +1692,6 @@ allocate_string (void)
ASAN_UNPOISON_STRING (s); ASAN_UNPOISON_STRING (s);
string_free_list = NEXT_FREE_LISP_STRING (s); string_free_list = NEXT_FREE_LISP_STRING (s);
MALLOC_UNBLOCK_INPUT;
++strings_consed; ++strings_consed;
tally_consing (sizeof *s); tally_consing (sizeof *s);
@ -1810,8 +1735,6 @@ allocate_string_data (struct Lisp_String *s,
of string data. */ of string data. */
ptrdiff_t needed = sdata_size (nbytes); ptrdiff_t needed = sdata_size (nbytes);
MALLOC_BLOCK_INPUT;
if (nbytes > LARGE_STRING_BYTES || immovable) if (nbytes > LARGE_STRING_BYTES || immovable)
{ {
size_t size = FLEXSIZEOF (struct sblock, data, needed); 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); b->next_free = (sdata *) ((char *) data + needed + GC_STRING_EXTRA);
eassert ((uintptr_t) b->next_free % alignof (sdata) == 0); eassert ((uintptr_t) b->next_free % alignof (sdata) == 0);
MALLOC_UNBLOCK_INPUT;
s->u.s.data = SDATA_DATA (data); s->u.s.data = SDATA_DATA (data);
#ifdef GC_CHECK_STRING_BYTES #ifdef GC_CHECK_STRING_BYTES
SDATA_NBYTES (data) = nbytes; SDATA_NBYTES (data) = nbytes;
@ -2606,8 +2527,6 @@ make_float (double float_value)
{ {
register Lisp_Object val; register Lisp_Object val;
MALLOC_BLOCK_INPUT;
if (float_free_list) if (float_free_list)
{ {
XSETFLOAT (val, float_free_list); XSETFLOAT (val, float_free_list);
@ -2631,8 +2550,6 @@ make_float (double float_value)
float_block_index++; float_block_index++;
} }
MALLOC_UNBLOCK_INPUT;
XFLOAT_INIT (val, float_value); XFLOAT_INIT (val, float_value);
eassert (!XFLOAT_MARKED_P (XFLOAT (val))); eassert (!XFLOAT_MARKED_P (XFLOAT (val)));
tally_consing (sizeof (struct Lisp_Float)); tally_consing (sizeof (struct Lisp_Float));
@ -2730,8 +2647,6 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
{ {
register Lisp_Object val; register Lisp_Object val;
MALLOC_BLOCK_INPUT;
if (cons_free_list) if (cons_free_list)
{ {
ASAN_UNPOISON_CONS (cons_free_list); ASAN_UNPOISON_CONS (cons_free_list);
@ -2755,8 +2670,6 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
cons_block_index++; cons_block_index++;
} }
MALLOC_UNBLOCK_INPUT;
XSETCAR (val, car); XSETCAR (val, car);
XSETCDR (val, cdr); XSETCDR (val, cdr);
eassert (!XCONS_MARKED_P (XCONS (val))); 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; ptrdiff_t nbytes = header_size + len * word_size;
struct Lisp_Vector *p; struct Lisp_Vector *p;
MALLOC_BLOCK_INPUT;
#ifdef DOUG_LEA_MALLOC #ifdef DOUG_LEA_MALLOC
if (!mmap_lisp_allowed_p ()) if (!mmap_lisp_allowed_p ())
mallopt (M_MMAP_MAX, 0); mallopt (M_MMAP_MAX, 0);
@ -3518,8 +3429,6 @@ allocate_vectorlike (ptrdiff_t len, bool clearit)
tally_consing (nbytes); tally_consing (nbytes);
vector_cells_consed += len; vector_cells_consed += len;
MALLOC_UNBLOCK_INPUT;
return p; return p;
} }
@ -3817,8 +3726,6 @@ Its value is void, and its function definition and property list are nil. */)
CHECK_STRING (name); CHECK_STRING (name);
MALLOC_BLOCK_INPUT;
if (symbol_free_list) if (symbol_free_list)
{ {
ASAN_UNPOISON_SYMBOL (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++; symbol_block_index++;
} }
MALLOC_UNBLOCK_INPUT;
init_symbol (val, name); init_symbol (val, name);
tally_consing (sizeof (struct Lisp_Symbol)); tally_consing (sizeof (struct Lisp_Symbol));
symbols_consed++; symbols_consed++;
@ -4250,16 +4155,12 @@ memory_full (size_t nbytes)
bool enough_free_memory = false; bool enough_free_memory = false;
if (SPARE_MEMORY < nbytes) if (SPARE_MEMORY < nbytes)
{ {
void *p; void *p = malloc (SPARE_MEMORY);
MALLOC_BLOCK_INPUT;
p = malloc (SPARE_MEMORY);
if (p) if (p)
{ {
free (p); free (p);
enough_free_memory = true; enough_free_memory = true;
} }
MALLOC_UNBLOCK_INPUT;
} }
if (! enough_free_memory) if (! enough_free_memory)