From: Paul Eggert Date: Mon, 31 Aug 2020 06:40:11 +0000 (-0700) Subject: Remove mark_maybe_object X-Git-Tag: emacs-28.0.90~6306 X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=7e2f6f8448f9d98e90e0343e2aeba22a7985480f;p=emacs.git Remove mark_maybe_object * src/alloc.c (mark_maybe_object, mark_maybe_objects): Remove. (mark_objects): New function. * src/eval.c (mark_specpdl): Use mark_objects instead of mark_maybe_objects, since the array now has only valid Lisp objects. * src/lisp.h (SAFE_ALLOCA_LISP_EXTRA): When allocating a large array, clear it so that it contains only valid Lisp objects. This is simpler and safer, and does not hurt performance significantly on my usual benchmark as the code is executed so rarely. --- diff --git a/src/alloc.c b/src/alloc.c index 5453c54d931..2f66b5eef52 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -4680,117 +4680,33 @@ live_small_vector_p (struct mem_node *m, void *p) return live_small_vector_holding (m, p) == p; } -/* Mark OBJ if we can prove it's a Lisp_Object. */ +/* If P points to Lisp data, mark that as live if it isn't already + marked. */ static void -mark_maybe_object (Lisp_Object obj) +mark_maybe_pointer (void *p) { + struct mem_node *m; + #if USE_VALGRIND - VALGRIND_MAKE_MEM_DEFINED (&obj, sizeof (obj)); + VALGRIND_MAKE_MEM_DEFINED (&p, sizeof (p)); #endif - int type_tag = XTYPE (obj); - intptr_t pointer_word_tag = LISP_WORD_TAG (type_tag), offset, ipo; - - switch (type_tag) - { - case_Lisp_Int: case Lisp_Type_Unused0: - return; - - case Lisp_Symbol: - offset = (intptr_t) lispsym; - break; - - default: - offset = 0; - break; - } - - INT_ADD_WRAPV ((intptr_t) XLP (obj), offset - pointer_word_tag, &ipo); - void *po = (void *) ipo; - /* If the pointer is in the dump image and the dump has a record of the object starting at the place where the pointer points, we definitely have an object. If the pointer is in the dump image and the dump has no idea what the pointer is pointing at, we definitely _don't_ have an object. */ - if (pdumper_object_p (po)) + if (pdumper_object_p (p)) { /* Don't use pdumper_object_p_precise here! It doesn't check the tag bits. OBJ here might be complete garbage, so we need to verify both the pointer and the tag. */ - if (pdumper_find_object_type (po) == type_tag) - mark_object (obj); - return; - } - - struct mem_node *m = mem_find (po); - - if (m != MEM_NIL) - { - bool mark_p = false; - - switch (type_tag) - { - case Lisp_String: - mark_p = m->type == MEM_TYPE_STRING && live_string_p (m, po); - break; - - case Lisp_Cons: - mark_p = m->type == MEM_TYPE_CONS && live_cons_p (m, po); - break; - - case Lisp_Symbol: - mark_p = m->type == MEM_TYPE_SYMBOL && live_symbol_p (m, po); - break; - - case Lisp_Float: - mark_p = m->type == MEM_TYPE_FLOAT && live_float_p (m, po); - break; - - case Lisp_Vectorlike: - mark_p = (m->type == MEM_TYPE_VECTOR_BLOCK - ? live_small_vector_p (m, po) - : (m->type == MEM_TYPE_VECTORLIKE - && live_large_vector_p (m, po))); - break; - - default: - eassume (false); - } - - if (mark_p) - mark_object (obj); - } -} - -void -mark_maybe_objects (Lisp_Object const *array, ptrdiff_t nelts) -{ - for (Lisp_Object const *lim = array + nelts; array < lim; array++) - mark_maybe_object (*array); -} - -/* If P points to Lisp data, mark that as live if it isn't already - marked. */ - -static void -mark_maybe_pointer (void *p) -{ - struct mem_node *m; - -#if USE_VALGRIND - VALGRIND_MAKE_MEM_DEFINED (&p, sizeof (p)); -#endif - - if (pdumper_object_p (p)) - { int type = pdumper_find_object_type (p); if (pdumper_valid_object_type_p (type)) mark_object (type == Lisp_Symbol ? make_lisp_symbol (p) : make_lisp_ptr (p, type)); - /* See mark_maybe_object for why we can confidently return. */ return; } @@ -6570,6 +6486,13 @@ mark_hash_table (struct Lisp_Vector *ptr) } } +void +mark_objects (Lisp_Object *obj, ptrdiff_t n) +{ + for (ptrdiff_t i = 0; i < n; i++) + mark_object (obj[i]); +} + /* Determine type of generic Lisp_Object and mark it accordingly. This function implements a straightforward depth-first marking diff --git a/src/eval.c b/src/eval.c index 9daae92e55a..a9bce552b18 100644 --- a/src/eval.c +++ b/src/eval.c @@ -3960,7 +3960,7 @@ mark_specpdl (union specbinding *first, union specbinding *ptr) break; case SPECPDL_UNWIND_ARRAY: - mark_maybe_objects (pdl->unwind_array.array, pdl->unwind_array.nelts); + mark_objects (pdl->unwind_array.array, pdl->unwind_array.nelts); break; case SPECPDL_UNWIND_EXCURSION: diff --git a/src/lisp.h b/src/lisp.h index 7983339ac50..745c056bd36 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -3767,12 +3767,12 @@ extern AVOID memory_full (size_t); extern AVOID buffer_memory_full (ptrdiff_t); extern bool survives_gc_p (Lisp_Object); extern void mark_object (Lisp_Object); +extern void mark_objects (Lisp_Object *, ptrdiff_t); #if defined REL_ALLOC && !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC extern void refill_memory_reserve (void); #endif extern void alloc_unexec_pre (void); extern void alloc_unexec_post (void); -extern void mark_maybe_objects (Lisp_Object const *, ptrdiff_t); extern void mark_stack (char const *, char const *); extern void flush_stack_call_func1 (void (*func) (void *arg), void *arg); @@ -4884,7 +4884,10 @@ safe_free_unbind_to (ptrdiff_t count, ptrdiff_t sa_count, Lisp_Object val) (buf) = AVAIL_ALLOCA (alloca_nbytes); \ else \ { \ - (buf) = xmalloc (alloca_nbytes); \ + /* Although only the first nelt words need clearing, \ + typically EXTRA is 0 or small so just use xzalloc; \ + this is simpler and often faster. */ \ + (buf) = xzalloc (alloca_nbytes); \ record_unwind_protect_array (buf, nelt); \ } \ } while (false)