39 files changed, 210 insertions, 722 deletions
diff --git a/src/alloc.c b/src/alloc.c
index 522547661a5..62d82664ac6 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -34,7 +34,6 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include "bignum.h"
 #include "dispextern.h"
 #include "intervals.h"
-#include "puresize.h"
 #include "sheap.h"
 #include "sysstdio.h"
 #include "systime.h"
@@ -334,33 +333,6 @@ static char *spare_memory[7];
 #define SPARE_MEMORY (1 << 14)
-/* Initialize it to a nonzero value to force it into data space
-   (rather than bss space).  That way unexec will remap it into text
-   space (pure), on some systems.  We have not implemented the
-   remapping on more recent systems because this is less important
-   nowadays than in the days of small memories and timesharing.  */
-EMACS_INT pure[(PURESIZE + sizeof (EMACS_INT) - 1) / sizeof (EMACS_INT)] = {1,};
-#define PUREBEG (char *) pure
-/* Pointer to the pure area, and its size.  */
-static char *purebeg;
-static ptrdiff_t pure_size;
-/* Number of bytes of pure storage used before pure storage overflowed.
-   If this is non-zero, this implies that an overflow occurred.  */
-static ptrdiff_t pure_bytes_used_before_overflow;
-/* Index in pure at which next pure Lisp object will be allocated..  */
-static ptrdiff_t pure_bytes_used_lisp;
-/* Number of bytes allocated for non-Lisp objects in pure storage.  */
-static ptrdiff_t pure_bytes_used_non_lisp;
 /* If positive, garbage collection is inhibited.  Otherwise, zero.  */
 static intptr_t garbage_collection_inhibited;
@@ -561,16 +533,6 @@ Lisp_Object const *staticvec[NSTATICS]
 int staticidx;
-static void *pure_alloc (size_t, int);
-/* Return PTR rounded up to the next multiple of ALIGNMENT.  */
-static void *
-pointer_align (void *ptr, int alignment)
-{
-  return (void *) ROUNDUP ((uintptr_t) ptr, alignment);
-}
 /* Extract the pointer hidden within O.  */
 static ATTRIBUTE_NO_SANITIZE_UNDEFINED void *
@@ -1152,6 +1114,16 @@ struct ablocks
  (1 & (intptr_t) ABLOCKS_BUSY (abase) ? abase : ((void **) (abase))[-1])
 #endif
+/* Return PTR rounded up to the next multiple of ALIGNMENT.  */
+#ifndef USE_ALIGNED_ALLOC
+static void *
+pointer_align (void *ptr, int alignment)
+{
+  return (void *) ROUNDUP ((uintptr_t) ptr, alignment);
+}
+#endif
 /* The list of free ablock.   */
 static struct ablock *free_ablock;
@@ -1714,7 +1686,7 @@ string_bytes (struct Lisp_String *s)
  ptrdiff_t nbytes =
    (s->u.s.size_byte < 0 ? s->u.s.size & ~ARRAY_MARK_FLAG : s->u.s.size_byte);
-  if (!PURE_P (s) && !pdumper_object_p (s) && s->u.s.data
+  if (!pdumper_object_p (s) && s->u.s.data
      && nbytes != SDATA_NBYTES (SDATA_OF_STRING (s)))
    emacs_abort ();
  return nbytes;
@@ -2529,7 +2501,7 @@ pin_string (Lisp_Object string)
  unsigned char *data = s->u.s.data;
  if (!(size > LARGE_STRING_BYTES
-        || PURE_P (data) || pdumper_object_p (data)
+        || pdumper_object_p (data)
        || s->u.s.size_byte == -3))
    {
      eassert (s->u.s.size_byte == -1);
@@ -2789,17 +2761,16 @@ list5 (Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3, Lisp_Object arg4,
 }
 /* Make a list of COUNT Lisp_Objects, where ARG is the first one.
-   Use CONS to construct the pairs.  AP has any remaining args.  */
+   AP has any remaining args.  */
 static Lisp_Object
-cons_listn (ptrdiff_t count, Lisp_Object arg,
+cons_listn (ptrdiff_t count, Lisp_Object arg, va_list ap)
-            Lisp_Object (*cons) (Lisp_Object, Lisp_Object), va_list ap)
 {
  eassume (0 < count);
-  Lisp_Object val = cons (arg, Qnil);
+  Lisp_Object val = Fcons (arg, Qnil);
  Lisp_Object tail = val;
  for (ptrdiff_t i = 1; i < count; i++)
    {
-      Lisp_Object elem = cons (va_arg (ap, Lisp_Object), Qnil);
+      Lisp_Object elem = Fcons (va_arg (ap, Lisp_Object), Qnil);
      XSETCDR (tail, elem);
      tail = elem;
    }
@@ -2812,18 +2783,7 @@ listn (ptrdiff_t count, Lisp_Object arg1, ...)
 {
  va_list ap;
  va_start (ap, arg1);
-  Lisp_Object val = cons_listn (count, arg1, Fcons, ap);
+  Lisp_Object val = cons_listn (count, arg1, ap);
-  va_end (ap);
-  return val;
-}
-/* Make a pure list of COUNT Lisp_Objects, where ARG1 is the first one.  */
-Lisp_Object
-pure_listn (ptrdiff_t count, Lisp_Object arg1, ...)
-{
-  va_list ap;
-  va_start (ap, arg1);
-  Lisp_Object val = cons_listn (count, arg1, pure_cons, ap);
  va_end (ap);
  return val;
 }
@@ -2989,7 +2949,7 @@ static struct Lisp_Vector *vector_free_lists[VECTOR_MAX_FREE_LIST_INDEX];
 static struct large_vector *large_vectors;
-/* The only vector with 0 slots, allocated from pure space.  */
+/* The only vector with 0 slots.  */
 Lisp_Object zero_vector;
@@ -3628,13 +3588,6 @@ struct symbol_block
 static struct symbol_block *symbol_block;
 static int symbol_block_index = SYMBOL_BLOCK_SIZE;
-/* Pointer to the first symbol_block that contains pinned symbols.
-   Tests for 24.4 showed that at dump-time, Emacs contains about 15K symbols,
-   10K of which are pinned (and all but 250 of them are interned in obarray),
-   whereas a "typical session" has in the order of 30K symbols.
-   `symbol_block_pinned' lets mark_pinned_symbols scan only 15K symbols rather
-   than 30K to find the 10K symbols we need to mark.  */
-static struct symbol_block *symbol_block_pinned;
 /* List of free symbols.  */
@@ -3660,7 +3613,6 @@ init_symbol (Lisp_Object val, Lisp_Object name)
  p->u.s.interned = SYMBOL_UNINTERNED;
  p->u.s.trapped_write = SYMBOL_UNTRAPPED_WRITE;
  p->u.s.declared_special = false;
-  p->u.s.pinned = false;
 }
 DEFUN ("make-symbol", Fmake_symbol, Smake_symbol, 1, 1, 0,
@@ -5268,8 +5220,6 @@ valid_lisp_object_p (Lisp_Object obj)
    return 1;
  void *p = XPNTR (obj);
-  if (PURE_P (p))
-    return 1;
  if (BARE_SYMBOL_P (obj) && c_symbol_p (p))
    return ((char *) p - (char *) lispsym) % sizeof lispsym[0] == 0;
@@ -5325,121 +5275,8 @@ valid_lisp_object_p (Lisp_Object obj)
  return 0;
 }
-/***********************************************************************
-                       Pure Storage Management
- ***********************************************************************/
-/* Allocate room for SIZE bytes from pure Lisp storage and return a
-   pointer to it.  TYPE is the Lisp type for which the memory is
-   allocated.  TYPE < 0 means it's not used for a Lisp object,
-   and that the result should have an alignment of -TYPE.
-   The bytes are initially zero.
-   If pure space is exhausted, allocate space from the heap.  This is
-   merely an expedient to let Emacs warn that pure space was exhausted
-   and that Emacs should be rebuilt with a larger pure space.  */
-static void *
-pure_alloc (size_t size, int type)
-{
-  void *result;
- again:
-  if (type >= 0)
-    {
-      /* Allocate space for a Lisp object from the beginning of the free
-         space with taking account of alignment.  */
-      result = pointer_align (purebeg + pure_bytes_used_lisp, LISP_ALIGNMENT);
-      pure_bytes_used_lisp = ((char *)result - (char *)purebeg) + size;
-    }
-  else
-    {
-      /* Allocate space for a non-Lisp object from the end of the free
-         space.  */
-      ptrdiff_t unaligned_non_lisp = pure_bytes_used_non_lisp + size;
-      char *unaligned = purebeg + pure_size - unaligned_non_lisp;
-      int decr = (intptr_t) unaligned & (-1 - type);
-      pure_bytes_used_non_lisp = unaligned_non_lisp + decr;
-      result = unaligned - decr;
-    }
-  pure_bytes_used = pure_bytes_used_lisp + pure_bytes_used_non_lisp;
-  if (pure_bytes_used <= pure_size)
-    return result;
-  /* Don't allocate a large amount here,
-     because it might get mmap'd and then its address
-     might not be usable.  */
-  int small_amount = 10000;
-  eassert (size <= small_amount - LISP_ALIGNMENT);
-  purebeg = xzalloc (small_amount);
-  pure_size = small_amount;
-  pure_bytes_used_before_overflow += pure_bytes_used - size;
-  pure_bytes_used = 0;
-  pure_bytes_used_lisp = pure_bytes_used_non_lisp = 0;
-  /* Can't GC if pure storage overflowed because we can't determine
-     if something is a pure object or not.  */
-  garbage_collection_inhibited++;
-  goto again;
-}
-#ifdef HAVE_UNEXEC
-/* Print a warning if PURESIZE is too small.  */
-void
-check_pure_size (void)
-{
-  if (pure_bytes_used_before_overflow)
-    message (("emacs:0:Pure Lisp storage overflow (approx. %"pI"d"
-              " bytes needed)"),
-             pure_bytes_used + pure_bytes_used_before_overflow);
-}
-#endif
-/* Return a string allocated in pure space.  DATA is a buffer holding
-   NCHARS characters, and NBYTES bytes of string data.  MULTIBYTE
-   means make the result string multibyte.
-   Must get an error if pure storage is full, since if it cannot hold
-   a large string it may be able to hold conses that point to that
-   string; then the string is not protected from gc.  */
-Lisp_Object
-make_pure_string (const char *data,
-                  ptrdiff_t nchars, ptrdiff_t nbytes, bool multibyte)
-{
-  if (multibyte)
-    return make_multibyte_string (data, nchars, nbytes);
-  else
-    return make_unibyte_string (data, nchars);
-}
-/* Return a string allocated in pure space.  Do not
-   allocate the string data, just point to DATA.  */
-Lisp_Object
-make_pure_c_string (const char *data, ptrdiff_t nchars)
-{
-  return make_unibyte_string (data, nchars);
-}
 static Lisp_Object purecopy (Lisp_Object obj);
-/* Return a cons allocated from pure space.  Give it pure copies
-   of CAR as car and CDR as cdr.  */
-Lisp_Object
-pure_cons (Lisp_Object car, Lisp_Object cdr)
-{
-  return Fcons (car, cdr);
-}
 DEFUN ("purecopy", Fpurecopy, Spurecopy, 1, 1, 0,
       doc: /* Make a copy of object OBJ in pure storage.
 Recursively copies contents of vectors and cons cells.
@@ -5455,19 +5292,10 @@ Does not copy symbols.  Copies strings without text properties.  */)
    return purecopy (obj);
 }
-/* Pinned objects are marked before every GC cycle.  */
-static struct pinned_object
-{
-  Lisp_Object object;
-  struct pinned_object *next;
-} *pinned_objects;
 static Lisp_Object
 purecopy (Lisp_Object obj)
 {
-  if (FIXNUMP (obj)
+  if (FIXNUMP (obj) || SUBRP (obj))
-      || (! SYMBOLP (obj) && PURE_P (XPNTR (obj)))
-      || SUBRP (obj))
    return obj;    /* Already pure.  */
  if (HASH_TABLE_P (Vpurify_flag)) /* Hash consing.  */
@@ -5475,12 +5303,12 @@ purecopy (Lisp_Object obj)
      Lisp_Object tmp = Fgethash (obj, Vpurify_flag, Qnil);
      if (!NILP (tmp))
        return tmp;
+      Fputhash (obj, obj, Vpurify_flag);
    }
  return obj;
 }
 /***********************************************************************
                          Protection from GC
@@ -5672,31 +5500,6 @@ compact_undo_list (Lisp_Object list)
 }
 static void
-mark_pinned_objects (void)
-{
-  for (struct pinned_object *pobj = pinned_objects; pobj; pobj = pobj->next)
-    mark_object (pobj->object);
-}
-static void
-mark_pinned_symbols (void)
-{
-  struct symbol_block *sblk;
-  int lim = (symbol_block_pinned == symbol_block
-             ? symbol_block_index : SYMBOL_BLOCK_SIZE);
-  for (sblk = symbol_block_pinned; sblk; sblk = sblk->next)
-    {
-      struct Lisp_Symbol *sym = sblk->symbols, *end = sym + lim;
-      for (; sym < end; ++sym)
-        if (sym->u.s.pinned)
-          mark_object (make_lisp_symbol (sym));
-      lim = SYMBOL_BLOCK_SIZE;
-    }
-}
-static void
 visit_vectorlike_root (struct gc_root_visitor visitor,
                       struct Lisp_Vector *ptr,
                       enum gc_root_type type)
@@ -5960,8 +5763,6 @@ garbage_collect (void)
  struct gc_root_visitor visitor = { .visit = mark_object_root_visitor };
  visit_static_gc_roots (visitor);
-  mark_pinned_objects ();
-  mark_pinned_symbols ();
  mark_lread ();
  mark_terminals ();
  mark_kboards ();
@@ -6088,10 +5889,6 @@ where each entry has the form (NAME SIZE USED FREE), where:
  keeps around for future allocations (maybe because it does not know how
  to return them to the OS).
-However, if there was overflow in pure space, and Emacs was dumped
-using the \"unexec\" method, `garbage-collect' returns nil, because
-real GC can't be done.
 Note that calling this function does not guarantee that absolutely all
 unreachable objects will be garbage-collected.  Emacs uses a
 mark-and-sweep garbage collector, but is conservative when it comes to
@@ -6519,8 +6316,6 @@ process_mark_stack (ptrdiff_t base_sp)
      Lisp_Object obj = mark_stack_pop ();
    mark_obj: ;
      void *po = XPNTR (obj);
-      if (PURE_P (po))
-        continue;
 #if GC_REMEMBER_LAST_MARKED
      last_marked[last_marked_index++] = obj;
@@ -6746,8 +6541,7 @@ process_mark_stack (ptrdiff_t base_sp)
                break;
              default: emacs_abort ();
              }
-            if (!PURE_P (XSTRING (ptr->u.s.name)))
+            set_string_marked (XSTRING (ptr->u.s.name));
-              set_string_marked (XSTRING (ptr->u.s.name));
            mark_interval_tree (string_intervals (ptr->u.s.name));
            /* Inner loop to mark next symbol in this bucket, if any.  */
            po = ptr = ptr->u.s.next;
@@ -6881,7 +6675,7 @@ survives_gc_p (Lisp_Object obj)
      emacs_abort ();
    }
-  return survives_p || PURE_P (XPNTR (obj));
+  return survives_p;
 }
@@ -7482,7 +7276,7 @@ init_alloc_once (void)
 {
  gc_cons_threshold = GC_DEFAULT_THRESHOLD;
  /* Even though Qt's contents are not set up, its address is known.  */
-  Vpurify_flag = Qt;
+  Vpurify_flag = Qt;  /* FIXME: Redundant with setting in lread.c.  */
  PDUMPER_REMEMBER_SCALAR (buffer_defaults.header);
  PDUMPER_REMEMBER_SCALAR (buffer_local_symbols.header);
@@ -7501,8 +7295,6 @@ init_alloc_once (void)
 static void
 init_alloc_once_for_pdumper (void)
 {
-  purebeg = PUREBEG;
-  pure_size = PURESIZE;
  mem_init ();
 #ifdef DOUG_LEA_MALLOC
@@ -7546,7 +7338,7 @@ If this portion is smaller than `gc-cons-threshold', this is ignored.  */);
  Vgc_cons_percentage = make_float (0.1);
  DEFVAR_INT ("pure-bytes-used", pure_bytes_used,
-              doc: /* Number of bytes of shareable Lisp data allocated so far.  */);
+              doc: /* No longer used.  */);
  DEFVAR_INT ("cons-cells-consed", cons_cells_consed,
              doc: /* Number of cons cells that have been consed so far.  */);
@@ -7572,9 +7364,13 @@ If this portion is smaller than `gc-cons-threshold', this is ignored.  */);
  DEFVAR_LISP ("purify-flag", Vpurify_flag,
               doc: /* Non-nil means loading Lisp code in order to dump an executable.
-This means that certain objects should be allocated in shared (pure) space.
+This used to mean that certain objects should be allocated in shared (pure)
-It can also be set to a hash-table, in which case this table is used to
+space.  It can also be set to a hash-table, in which case this table is used
-do hash-consing of the objects allocated to pure space.  */);
+to do hash-consing of the objects allocated to pure space.
+The hash-consing may still apply, but objects are not allocated in purespace
+any more.
+This flag is still used in a few places not to decide where objects are
+allocated but to know if we're in the preload phase of Emacs's build.  */);
  DEFVAR_BOOL ("garbage-collection-messages", garbage_collection_messages,
               doc: /* Non-nil means display messages at start and end of garbage collection.  */);
@@ -7590,10 +7386,10 @@ do hash-consing of the objects allocated to pure space.  */);
  /* We build this in advance because if we wait until we need it, we might
     not be able to allocate the memory to hold it.  */
  Vmemory_signal_data
-    = pure_list (Qerror,
+    = list (Qerror,
-                 build_pure_c_string ("Memory exhausted--use"
+            build_string ("Memory exhausted--use"
-                                      " M-x save-some-buffers then"
+                          " M-x save-some-buffers then"
-                                      " exit and restart Emacs"));
+                          " exit and restart Emacs"));
  DEFVAR_LISP ("memory-full", Vmemory_full,
               doc: /* Non-nil means Emacs cannot get much more Lisp memory.  */);
diff --git a/src/buffer.c b/src/buffer.c
index 509ce51b55e..834a4a03b5b 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5308,8 +5308,8 @@ init_buffer_once (void)
  set_buffer_intervals (&buffer_defaults, NULL);
  set_buffer_intervals (&buffer_local_symbols, NULL);
  /* This is not strictly necessary, but let's make them initialized.  */
-  bset_name (&buffer_defaults, build_pure_c_string (" *buffer-defaults*"));
+  bset_name (&buffer_defaults, build_string (" *buffer-defaults*"));
-  bset_name (&buffer_local_symbols, build_pure_c_string (" *buffer-local-symbols*"));
+  bset_name (&buffer_local_symbols, build_string (" *buffer-local-symbols*"));
  BUFFER_PVEC_INIT (&buffer_defaults);
  BUFFER_PVEC_INIT (&buffer_local_symbols);
@@ -5317,7 +5317,7 @@ init_buffer_once (void)
  /* Must do these before making the first buffer! */
  /* real setup is done in bindings.el */
-  bset_mode_line_format (&buffer_defaults, build_pure_c_string ("%-"));
+  bset_mode_line_format (&buffer_defaults, build_string ("%-"));
  bset_header_line_format (&buffer_defaults, Qnil);
  bset_tab_line_format (&buffer_defaults, Qnil);
  bset_abbrev_mode (&buffer_defaults, Qnil);
@@ -5384,7 +5384,7 @@ init_buffer_once (void)
  current_buffer = 0;
  pdumper_remember_lv_ptr_raw (&current_buffer, Lisp_Vectorlike);
-  QSFundamental = build_pure_c_string ("Fundamental");
+  QSFundamental = build_string ("Fundamental");
  DEFSYM (Qfundamental_mode, "fundamental-mode");
  bset_major_mode (&buffer_defaults, Qfundamental_mode);
@@ -5398,10 +5398,10 @@ init_buffer_once (void)
  /* Super-magic invisible buffer.  */
  Vprin1_to_string_buffer =
-    Fget_buffer_create (build_pure_c_string (" prin1"), Qt);
+    Fget_buffer_create (build_string (" prin1"), Qt);
  Vbuffer_alist = Qnil;
-  Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*"), Qnil));
+  Fset_buffer (Fget_buffer_create (build_string ("*scratch*"), Qnil));
  inhibit_modification_hooks = 0;
 }
@@ -5584,9 +5584,9 @@ syms_of_buffer (void)
               Qoverwrite_mode_binary));
  Fput (Qprotected_field, Qerror_conditions,
-        pure_list (Qprotected_field, Qerror));
+        list (Qprotected_field, Qerror));
  Fput (Qprotected_field, Qerror_message,
-        build_pure_c_string ("Attempt to modify a protected field"));
+        build_string ("Attempt to modify a protected field"));
  DEFSYM (Qclone_indirect_buffer_hook, "clone-indirect-buffer-hook");
diff --git a/src/bytecode.c b/src/bytecode.c
index d75767bb0c5..3be5e8a3162 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -27,7 +27,6 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include "keyboard.h"
 #include "syntax.h"
 #include "window.h"
-#include "puresize.h"
 /* Work around GCC bug 54561.  */
 #if GNUC_PREREQ (4, 3, 0)
@@ -1582,7 +1581,6 @@ exec_byte_code (Lisp_Object fun, ptrdiff_t args_template,
            Lisp_Object newval = POP;
            Lisp_Object cell = TOP;
            CHECK_CONS (cell);
-            CHECK_IMPURE (cell, XCONS (cell));
            XSETCAR (cell, newval);
            TOP = newval;
            NEXT;
@@ -1593,7 +1591,6 @@ exec_byte_code (Lisp_Object fun, ptrdiff_t args_template,
            Lisp_Object newval = POP;
            Lisp_Object cell = TOP;
            CHECK_CONS (cell);
-            CHECK_IMPURE (cell, XCONS (cell));
            XSETCDR (cell, newval);
            TOP = newval;
            NEXT;
diff --git a/src/callint.c b/src/callint.c
index ffa3b231eb5..7c2ce1b9e5e 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -862,10 +862,10 @@ syms_of_callint (void)
  callint_message = Qnil;
  staticpro (&callint_message);
-  preserved_fns = pure_list (intern_c_string ("region-beginning"),
+  preserved_fns = list (intern_c_string ("region-beginning"),
-                             intern_c_string ("region-end"),
+                        intern_c_string ("region-end"),
-                             intern_c_string ("point"),
+                        intern_c_string ("point"),
-                             intern_c_string ("mark"));
+                        intern_c_string ("mark"));
  staticpro (&preserved_fns);
  DEFSYM (Qlist, "list");
diff --git a/src/category.c b/src/category.c
index bedde0de45e..198b7f6f5ba 100644
--- a/src/category.c
+++ b/src/category.c
@@ -53,7 +53,7 @@ hash_get_category_set (Lisp_Object table, Lisp_Object category_set)
      (table, 1,
       make_hash_table (hashtest_equal, DEFAULT_HASH_SIZE,
                        DEFAULT_REHASH_SIZE, DEFAULT_REHASH_THRESHOLD,
-                        Qnil, false));
+                        Qnil));
  struct Lisp_Hash_Table *h = XHASH_TABLE (XCHAR_TABLE (table)->extras[1]);
  Lisp_Object hash;
  ptrdiff_t i = hash_lookup (h, category_set, &hash);
@@ -120,8 +120,6 @@ the current buffer's category table.  */)
  if (!NILP (CATEGORY_DOCSTRING (table, XFIXNAT (category))))
    error ("Category `%c' is already defined", (int) XFIXNAT (category));
-  if (!NILP (Vpurify_flag))
-    docstring = Fpurecopy (docstring);
  SET_CATEGORY_DOCSTRING (table, XFIXNAT (category), docstring);
  return Qnil;
diff --git a/src/coding.c b/src/coding.c
index 3fb4f148b1c..a4087b68343 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -11682,7 +11682,7 @@ syms_of_coding (void)
  Vcode_conversion_reused_workbuf = Qnil;
  staticpro (&Vcode_conversion_workbuf_name);
-  Vcode_conversion_workbuf_name = build_pure_c_string (" *code-conversion-work*");
+  Vcode_conversion_workbuf_name = build_string (" *code-conversion-work*");
  reused_workbuf_in_use = false;
  PDUMPER_REMEMBER_SCALAR (reused_workbuf_in_use);
@@ -11746,9 +11746,9 @@ syms_of_coding (void)
  /* Error signaled when there's a problem with detecting a coding system.  */
  DEFSYM (Qcoding_system_error, "coding-system-error");
  Fput (Qcoding_system_error, Qerror_conditions,
-        pure_list (Qcoding_system_error, Qerror));
+        list (Qcoding_system_error, Qerror));
  Fput (Qcoding_system_error, Qerror_message,
-        build_pure_c_string ("Invalid coding system"));
+        build_string ("Invalid coding system"));
  DEFSYM (Qtranslation_table, "translation-table");
  Fput (Qtranslation_table, Qchar_table_extra_slots, make_fixnum (2));
@@ -12023,22 +12023,22 @@ encoding standard output and error streams.  */);
  DEFVAR_LISP ("eol-mnemonic-unix", eol_mnemonic_unix,
               doc: /*
 String displayed in mode line for UNIX-like (LF) end-of-line format.  */);
-  eol_mnemonic_unix = build_pure_c_string (":");
+  eol_mnemonic_unix = build_string (":");
  DEFVAR_LISP ("eol-mnemonic-dos", eol_mnemonic_dos,
               doc: /*
 String displayed in mode line for DOS-like (CRLF) end-of-line format.  */);
-  eol_mnemonic_dos = build_pure_c_string ("\\");
+  eol_mnemonic_dos = build_string ("\\");
  DEFVAR_LISP ("eol-mnemonic-mac", eol_mnemonic_mac,
               doc: /*
 String displayed in mode line for MAC-like (CR) end-of-line format.  */);
-  eol_mnemonic_mac = build_pure_c_string ("/");
+  eol_mnemonic_mac = build_string ("/");
  DEFVAR_LISP ("eol-mnemonic-undecided", eol_mnemonic_undecided,
               doc: /*
 String displayed in mode line when end-of-line format is not yet determined.  */);
-  eol_mnemonic_undecided = build_pure_c_string (":");
+  eol_mnemonic_undecided = build_string (":");
  DEFVAR_LISP ("enable-character-translation", Venable_character_translation,
               doc: /*
@@ -12178,7 +12178,7 @@ internal character representation.  */);
      intern_c_string (":for-unibyte"),
      args[coding_arg_for_unibyte] = Qt,
      intern_c_string (":docstring"),
-      (build_pure_c_string
+      (build_string
       ("Do no conversion.\n"
        "\n"
        "When you visit a file with this coding, the file is read into a\n"
@@ -12198,7 +12198,7 @@ internal character representation.  */);
  plist[8] = intern_c_string (":charset-list");
  plist[9] = args[coding_arg_charset_list] = list1 (Qascii);
  plist[11] = args[coding_arg_for_unibyte] = Qnil;
-  plist[13] = build_pure_c_string ("No conversion on encoding, "
+  plist[13] = build_string ("No conversion on encoding, "
                                   "automatic conversion on decoding.");
  plist[15] = args[coding_arg_eol_type] = Qnil;
  args[coding_arg_plist] = CALLMANY (Flist, plist);
diff --git a/src/comp.c b/src/comp.c
index 0c78e60fc43..520b846a090 100644
--- a/src/comp.c
+++ b/src/comp.c
@@ -31,7 +31,6 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include <libgccjit.h>
 #include <epaths.h>
-#include "puresize.h"
 #include "window.h"
 #include "dynlib.h"
 #include "buffer.h"
@@ -676,7 +675,6 @@ helper_GET_SYMBOL_WITH_POSITION (Lisp_Object);
 static void *helper_link_table[] =
  { wrong_type_argument,
    helper_PSEUDOVECTOR_TYPEP_XUNTAG,
-    pure_write_error,
    push_handler,
    record_unwind_protect_excursion,
    helper_unbind_n,
@@ -3946,52 +3944,6 @@ static void define_SYMBOL_WITH_POS_SYM (void)
 }
 static void
-define_CHECK_IMPURE (void)
-{
-  gcc_jit_param *param[] =
-    { gcc_jit_context_new_param (comp.ctxt,
-                                 NULL,
-                                 comp.lisp_obj_type,
-                                 "obj"),
-      gcc_jit_context_new_param (comp.ctxt,
-                                 NULL,
-                                 comp.void_ptr_type,
-                                 "ptr") };
-  comp.check_impure =
-    gcc_jit_context_new_function (comp.ctxt, NULL,
-                                  GCC_JIT_FUNCTION_INTERNAL,
-                                  comp.void_type,
-                                  "CHECK_IMPURE",
-                                  2,
-                                  param,
-                                  0);
-    DECL_BLOCK (entry_block, comp.check_impure);
-    DECL_BLOCK (err_block, comp.check_impure);
-    DECL_BLOCK (ok_block, comp.check_impure);
-    comp.block = entry_block;
-    comp.func = comp.check_impure;
-    emit_cond_jump (emit_PURE_P (gcc_jit_param_as_rvalue (param[0])), /* FIXME */
-                    err_block,
-                    ok_block);
-    gcc_jit_block_end_with_void_return (ok_block, NULL);
-    gcc_jit_rvalue *pure_write_error_arg =
-      gcc_jit_param_as_rvalue (param[0]);
-    comp.block = err_block;
-    gcc_jit_block_add_eval (comp.block,
-                            NULL,
-                            emit_call (intern_c_string ("pure_write_error"),
-                                       comp.void_type, 1,&pure_write_error_arg,
-                                       false));
-    gcc_jit_block_end_with_void_return (err_block, NULL);
-}
-static void
 define_maybe_gc_or_quit (void)
 {
@@ -5114,10 +5066,10 @@ maybe_defer_native_compilation (Lisp_Object function_name,
  Lisp_Object src =
    concat2 (CALL1I (file-name-sans-extension, Vload_true_file_name),
-             build_pure_c_string (".el"));
+             build_string (".el"));
  if (NILP (Ffile_exists_p (src)))
    {
-      src = concat2 (src, build_pure_c_string (".gz"));
+      src = concat2 (src, build_string (".gz"));
      if (NILP (Ffile_exists_p (src)))
        return;
    }
@@ -5317,10 +5269,6 @@ load_comp_unit (struct Lisp_Native_Comp_Unit *comp_u, bool loading_dump,
          comp_u->data_vec = load_static_obj (comp_u, TEXT_DATA_RELOC_SYM);
          comp_u->data_impure_vec =
            load_static_obj (comp_u, TEXT_DATA_RELOC_IMPURE_SYM);
-          if (!NILP (Vpurify_flag))
-            /* Non impure can be copied into pure space.  */
-            comp_u->data_vec = Fpurecopy (comp_u->data_vec);
        }
      EMACS_INT d_vec_len = XFIXNUM (Flength (comp_u->data_vec));
@@ -5690,40 +5638,40 @@ compiled one.  */);
  Fput (Qnative_compiler_error, Qerror_conditions,
        pure_list (Qnative_compiler_error, Qerror));
  Fput (Qnative_compiler_error, Qerror_message,
-        build_pure_c_string ("Native compiler error"));
+        build_string ("Native compiler error"));
  DEFSYM (Qnative_ice, "native-ice");
  Fput (Qnative_ice, Qerror_conditions,
        pure_list (Qnative_ice, Qnative_compiler_error, Qerror));
  Fput (Qnative_ice, Qerror_message,
-        build_pure_c_string ("Internal native compiler error"));
+        build_string ("Internal native compiler error"));
  /* By the load machinery.  */
  DEFSYM (Qnative_lisp_load_failed, "native-lisp-load-failed");
  Fput (Qnative_lisp_load_failed, Qerror_conditions,
        pure_list (Qnative_lisp_load_failed, Qerror));
  Fput (Qnative_lisp_load_failed, Qerror_message,
-        build_pure_c_string ("Native elisp load failed"));
+        build_string ("Native elisp load failed"));
  DEFSYM (Qnative_lisp_wrong_reloc, "native-lisp-wrong-reloc");
  Fput (Qnative_lisp_wrong_reloc, Qerror_conditions,
        pure_list (Qnative_lisp_wrong_reloc, Qnative_lisp_load_failed, Qerror));
  Fput (Qnative_lisp_wrong_reloc, Qerror_message,
-        build_pure_c_string ("Primitive redefined or wrong relocation"));
+        build_string ("Primitive redefined or wrong relocation"));
  DEFSYM (Qwrong_register_subr_call, "wrong-register-subr-call");
  Fput (Qwrong_register_subr_call, Qerror_conditions,
        pure_list (Qwrong_register_subr_call, Qnative_lisp_load_failed, Qerror));
  Fput (Qwrong_register_subr_call, Qerror_message,
-        build_pure_c_string ("comp--register-subr can only be called during "
+        build_string ("comp--register-subr can only be called during "
-                            "native lisp load phase."));
+                      "native lisp load phase."));
  DEFSYM (Qnative_lisp_file_inconsistent, "native-lisp-file-inconsistent");
  Fput (Qnative_lisp_file_inconsistent, Qerror_conditions,
        pure_list (Qnative_lisp_file_inconsistent, Qnative_lisp_load_failed, Qerror));
  Fput (Qnative_lisp_file_inconsistent, Qerror_message,
-        build_pure_c_string ("eln file inconsistent with current runtime "
+        build_string ("eln file inconsistent with current runtime "
-                             "configuration, please recompile"));
+                      "configuration, please recompile"));
  defsubr (&Scomp__subr_signature);
  defsubr (&Scomp_el_to_eln_rel_filename);
diff --git a/src/conf_post.h b/src/conf_post.h
index 6ecebf36ab9..ab08cc63bb0 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -210,41 +210,8 @@ You lose; /* Emacs for DOS must be compiled with DJGPP */
 /* DATA_START is needed by vm-limit.c and unexcoff.c. */
 #define DATA_START (&etext + 1)
-/* Define one of these for easier conditionals.  */
-#ifdef HAVE_X_WINDOWS
-/* We need a little extra space, see ../../lisp/loadup.el and the
-   commentary below, in the non-X branch.  The 140KB number was
-   measured on GNU/Linux and on MS-Windows.  */
-#define SYSTEM_PURESIZE_EXTRA (-170000+140000)
-#else
-/* We need a little extra space, see ../../lisp/loadup.el.
-   As of 20091024, DOS-specific files use up 62KB of pure space.  But
-   overall, we end up wasting 130KB of pure space, because
-   BASE_PURESIZE starts at 1.47MB, while we need only 1.3MB (including
-   non-DOS specific files and load history; the latter is about 55K,
-   but depends on the depth of the top-level Emacs directory in the
-   directory tree).  Given the unknown policy of different DPMI
-   hosts regarding loading of untouched pages, I'm not going to risk
-   enlarging Emacs footprint by another 100+ KBytes.  */
-#define SYSTEM_PURESIZE_EXTRA (-170000+90000)
-#endif
 #endif  /* MSDOS */
-/* macOS / GNUstep need a bit more pure memory.  Of the existing knobs,
-   SYSTEM_PURESIZE_EXTRA seems like the least likely to cause problems.  */
-#ifdef HAVE_NS
-#if defined NS_IMPL_GNUSTEP
-#  define SYSTEM_PURESIZE_EXTRA 30000
-#elif defined DARWIN_OS
-#  define SYSTEM_PURESIZE_EXTRA 200000
-#endif
-#endif
-#ifdef CYGWIN
-#define SYSTEM_PURESIZE_EXTRA 50000
-#endif
 #if defined HAVE_NTGUI && !defined DebPrint
 # ifdef EMACSDEBUG
 extern void _DebPrint (const char *fmt, ...);
diff --git a/src/data.c b/src/data.c
index 1dbec4687b8..69ed68782b0 100644
--- a/src/data.c
+++ b/src/data.c
@@ -30,7 +30,6 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "bignum.h"
-#include "puresize.h"
 #include "character.h"
 #include "buffer.h"
 #include "keyboard.h"
@@ -144,12 +143,6 @@ wrong_type_argument (Lisp_Object predicate, Lisp_Object value)
 }
 void
-pure_write_error (Lisp_Object obj)
-{
-  xsignal2 (Qerror, build_string ("Attempt to modify read-only object"), obj);
-}
-void
 args_out_of_range (Lisp_Object a1, Lisp_Object a2)
 {
  xsignal2 (Qargs_out_of_range, a1, a2);
@@ -645,7 +638,6 @@ DEFUN ("setcar", Fsetcar, Ssetcar, 2, 2, 0,
  (register Lisp_Object cell, Lisp_Object newcar)
 {
  CHECK_CONS (cell);
-  CHECK_IMPURE (cell, XCONS (cell));
  XSETCAR (cell, newcar);
  return newcar;
 }
@@ -655,7 +647,6 @@ DEFUN ("setcdr", Fsetcdr, Ssetcdr, 2, 2, 0,
  (register Lisp_Object cell, Lisp_Object newcdr)
 {
  CHECK_CONS (cell);
-  CHECK_IMPURE (cell, XCONS (cell));
  XSETCDR (cell, newcdr);
  return newcdr;
 }
@@ -943,10 +934,6 @@ The return value is undefined.  */)
  (register Lisp_Object symbol, Lisp_Object definition, Lisp_Object docstring)
 {
  CHECK_SYMBOL (symbol);
-  if (!NILP (Vpurify_flag)
-      /* If `definition' is a keymap, immutable (and copying) is wrong.  */
-      && !KEYMAPP (definition))
-    definition = Fpurecopy (definition);
  defalias (symbol, definition);
@@ -2590,7 +2577,6 @@ bool-vector.  IDX starts at 0.  */)
  if (VECTORP (array))
    {
-      CHECK_IMPURE (array, XVECTOR (array));
      if (idxval < 0 || idxval >= ASIZE (array))
        args_out_of_range (array, idx);
      ASET (array, idxval, newelt);
@@ -2614,7 +2600,6 @@ bool-vector.  IDX starts at 0.  */)
    }
  else /* STRINGP */
    {
-      CHECK_IMPURE (array, XSTRING (array));
      if (idxval < 0 || idxval >= SCHARS (array))
        args_out_of_range (array, idx);
      CHECK_CHARACTER (newelt);
@@ -4143,7 +4128,7 @@ syms_of_data (void)
  DEFSYM (Qcdr, "cdr");
-  error_tail = pure_cons (Qerror, Qnil);
+  error_tail = Fcons (Qerror, Qnil);
  /* ERROR is used as a signaler for random errors for which nothing else is
     right.  */
@@ -4151,14 +4136,14 @@ syms_of_data (void)
  Fput (Qerror, Qerror_conditions,
        error_tail);
  Fput (Qerror, Qerror_message,
-        build_pure_c_string ("error"));
+        build_string ("error"));
 #define PUT_ERROR(sym, tail, msg)                       \
-  Fput (sym, Qerror_conditions, pure_cons (sym, tail)); \
+  Fput (sym, Qerror_conditions, Fcons (sym, tail)); \
-  Fput (sym, Qerror_message, build_pure_c_string (msg))
+  Fput (sym, Qerror_message, build_string (msg))
  PUT_ERROR (Qquit, Qnil, "Quit");
-  PUT_ERROR (Qminibuffer_quit, pure_cons (Qquit, Qnil), "Quit");
+  PUT_ERROR (Qminibuffer_quit, Fcons (Qquit, Qnil), "Quit");
  PUT_ERROR (Quser_error, error_tail, "");
  PUT_ERROR (Qwrong_length_argument, error_tail, "Wrong length argument");
@@ -4184,14 +4169,14 @@ syms_of_data (void)
  PUT_ERROR (Qno_catch, error_tail, "No catch for tag");
  PUT_ERROR (Qend_of_file, error_tail, "End of file during parsing");
-  arith_tail = pure_cons (Qarith_error, error_tail);
+  arith_tail = Fcons (Qarith_error, error_tail);
  Fput (Qarith_error, Qerror_conditions, arith_tail);
-  Fput (Qarith_error, Qerror_message, build_pure_c_string ("Arithmetic error"));
+  Fput (Qarith_error, Qerror_message, build_string ("Arithmetic error"));
  PUT_ERROR (Qbeginning_of_buffer, error_tail, "Beginning of buffer");
  PUT_ERROR (Qend_of_buffer, error_tail, "End of buffer");
  PUT_ERROR (Qbuffer_read_only, error_tail, "Buffer is read-only");
-  PUT_ERROR (Qtext_read_only, pure_cons (Qbuffer_read_only, error_tail),
+  PUT_ERROR (Qtext_read_only, Fcons (Qbuffer_read_only, error_tail),
             "Text is read-only");
  PUT_ERROR (Qinhibited_interaction, error_tail,
             "User interaction while inhibited");
@@ -4214,10 +4199,10 @@ syms_of_data (void)
  PUT_ERROR (Qunderflow_error, Fcons (Qrange_error, arith_tail),
             "Arithmetic underflow error");
-  recursion_tail = pure_cons (Qrecursion_error, error_tail);
+  recursion_tail = Fcons (Qrecursion_error, error_tail);
  Fput (Qrecursion_error, Qerror_conditions, recursion_tail);
-  Fput (Qrecursion_error, Qerror_message, build_pure_c_string
+  Fput (Qrecursion_error, Qerror_message,
-        ("Excessive recursive calling error"));
+        build_string ("Excessive recursive calling error"));
  PUT_ERROR (Qexcessive_variable_binding, recursion_tail,
             "Variable binding depth exceeds max-specpdl-size");
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 943a4aff8e7..0bc2a74f37f 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -1869,7 +1869,7 @@ syms_of_dbusbind (void)
  Fput (Qdbus_error, Qerror_conditions,
        list2 (Qdbus_error, Qerror));
  Fput (Qdbus_error, Qerror_message,
-        build_pure_c_string ("D-Bus error"));
+        build_string ("D-Bus error"));
  /* Lisp symbols of the system and session buses.  */
  DEFSYM (QCsystem, ":system");
@@ -1912,7 +1912,7 @@ syms_of_dbusbind (void)
               Vdbus_compiled_version,
    doc: /* The version of D-Bus Emacs is compiled against.  */);
 #ifdef DBUS_VERSION_STRING
-  Vdbus_compiled_version = build_pure_c_string (DBUS_VERSION_STRING);
+  Vdbus_compiled_version = build_string (DBUS_VERSION_STRING);
 #else
  Vdbus_compiled_version = Qnil;
 #endif
diff --git a/src/deps.mk b/src/deps.mk
index 39edd5c1dd3..cc3f685c7d2 100644
--- a/src/deps.mk
+++ b/src/deps.mk
@@ -132,10 +132,10 @@ insdel.o: insdel.c window.h buffer.h $(INTERVALS_H) blockinput.h character.h \
 keyboard.o: keyboard.c termchar.h termhooks.h termopts.h buffer.h character.h \
   commands.h frame.h window.h macros.h disptab.h keyboard.h syssignal.h \
   systime.h syntax.h $(INTERVALS_H) blockinput.h atimer.h composite.h \
-   xterm.h puresize.h msdos.h keymap.h w32term.h nsterm.h nsgui.h coding.h \
+   xterm.h msdos.h keymap.h w32term.h nsterm.h nsgui.h coding.h \
   process.h ../lib/unistd.h gnutls.h lisp.h globals.h $(config_h)
 keymap.o: keymap.c buffer.h commands.h keyboard.h termhooks.h blockinput.h \
-   atimer.h systime.h puresize.h character.h charset.h $(INTERVALS_H) \
+   atimer.h systime.h character.h charset.h $(INTERVALS_H) \
   keymap.h window.h coding.h frame.h lisp.h globals.h $(config_h)
 lastfile.o: lastfile.c $(config_h)
 macros.o: macros.c window.h buffer.h commands.h macros.h keyboard.h msdos.h \
@@ -267,12 +267,12 @@ xsettings.o: xterm.h xsettings.h lisp.h frame.h termhooks.h $(config_h) \
   atimer.h termopts.h globals.h
 ## The files of Lisp proper.
-alloc.o: alloc.c process.h frame.h window.h buffer.h  puresize.h syssignal.h \
+alloc.o: alloc.c process.h frame.h window.h buffer.h syssignal.h \
   keyboard.h blockinput.h atimer.h systime.h character.h lisp.h $(config_h) \
   $(INTERVALS_H) termhooks.h gnutls.h coding.h ../lib/unistd.h globals.h
 bytecode.o: bytecode.c buffer.h syntax.h character.h window.h dispextern.h \
  lisp.h globals.h $(config_h) msdos.h
-data.o: data.c buffer.h puresize.h character.h syssignal.h keyboard.h frame.h \
+data.o: data.c buffer.h character.h syssignal.h keyboard.h frame.h \
   termhooks.h systime.h coding.h composite.h dispextern.h font.h ccl.h \
   lisp.h globals.h $(config_h) msdos.h
 eval.o: eval.c commands.h keyboard.h blockinput.h atimer.h systime.h frame.h \
@@ -295,7 +295,7 @@ lread.o: lread.c commands.h keyboard.h buffer.h epaths.h character.h \
 composite.o: composite.c composite.h buffer.h character.h coding.h font.h \
   ccl.h frame.h termhooks.h $(INTERVALS_H) window.h \
   lisp.h globals.h $(config_h)
-intervals.o: intervals.c buffer.h $(INTERVALS_H) keyboard.h puresize.h \
+intervals.o: intervals.c buffer.h $(INTERVALS_H) keyboard.h \
   keymap.h lisp.h globals.h $(config_h) systime.h coding.h
 textprop.o: textprop.c buffer.h window.h $(INTERVALS_H) \
   lisp.h globals.h $(config_h)
diff --git a/src/doc.c b/src/doc.c
index 34b80d03aa9..09c44e48422 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -450,8 +450,6 @@ store_function_docstring (Lisp_Object obj, EMACS_INT offset)
        {
          tem = Fcdr (Fcdr (fun));
          if (CONSP (tem) && FIXNUMP (XCAR (tem)))
-            /* FIXME: This modifies typically pure hash-cons'd data, so its
-               correctness is quite delicate.  */
            XSETCAR (tem, make_fixnum (offset));
        }
    }
@@ -541,7 +539,6 @@ the same file name is found in the `doc-directory'.  */)
      int i = ARRAYELTS (buildobj);
      while (0 <= --i)
        Vbuild_files = Fcons (build_string (buildobj[i]), Vbuild_files);
-      Vbuild_files = Fpurecopy (Vbuild_files);
    }
  fd = emacs_open (name, O_RDONLY, 0);
diff --git a/src/emacs-module.c b/src/emacs-module.c
index 1c392d65df8..0b32eaf16b7 100644
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -1598,44 +1598,44 @@ syms_of_module (void)
  Vmodule_refs_hash
    = make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE,
                       DEFAULT_REHASH_SIZE, DEFAULT_REHASH_THRESHOLD,
-                       Qnil, false);
+                       Qnil);
  DEFSYM (Qmodule_load_failed, "module-load-failed");
  Fput (Qmodule_load_failed, Qerror_conditions,
-        pure_list (Qmodule_load_failed, Qerror));
+        list (Qmodule_load_failed, Qerror));
  Fput (Qmodule_load_failed, Qerror_message,
-        build_pure_c_string ("Module load failed"));
+        build_string ("Module load failed"));
  DEFSYM (Qmodule_open_failed, "module-open-failed");
  Fput (Qmodule_open_failed, Qerror_conditions,
-        pure_list (Qmodule_open_failed, Qmodule_load_failed, Qerror));
+        list (Qmodule_open_failed, Qmodule_load_failed, Qerror));
  Fput (Qmodule_open_failed, Qerror_message,
-        build_pure_c_string ("Module could not be opened"));
+        build_string ("Module could not be opened"));
  DEFSYM (Qmodule_not_gpl_compatible, "module-not-gpl-compatible");
  Fput (Qmodule_not_gpl_compatible, Qerror_conditions,
-        pure_list (Qmodule_not_gpl_compatible, Qmodule_load_failed, Qerror));
+        list (Qmodule_not_gpl_compatible, Qmodule_load_failed, Qerror));
  Fput (Qmodule_not_gpl_compatible, Qerror_message,
-        build_pure_c_string ("Module is not GPL compatible"));
+        build_string ("Module is not GPL compatible"));
  DEFSYM (Qmissing_module_init_function, "missing-module-init-function");
  Fput (Qmissing_module_init_function, Qerror_conditions,
-        pure_list (Qmissing_module_init_function, Qmodule_load_failed,
+        list (Qmissing_module_init_function, Qmodule_load_failed,
-                   Qerror));
+              Qerror));
  Fput (Qmissing_module_init_function, Qerror_message,
-        build_pure_c_string ("Module does not export an "
+        build_string ("Module does not export an "
                             "initialization function"));
  DEFSYM (Qmodule_init_failed, "module-init-failed");
  Fput (Qmodule_init_failed, Qerror_conditions,
-        pure_list (Qmodule_init_failed, Qmodule_load_failed, Qerror));
+        list (Qmodule_init_failed, Qmodule_load_failed, Qerror));
  Fput (Qmodule_init_failed, Qerror_message,
-        build_pure_c_string ("Module initialization failed"));
+        build_string ("Module initialization failed"));
  DEFSYM (Qinvalid_arity, "invalid-arity");
-  Fput (Qinvalid_arity, Qerror_conditions, pure_list (Qinvalid_arity, Qerror));
+  Fput (Qinvalid_arity, Qerror_conditions, list (Qinvalid_arity, Qerror));
  Fput (Qinvalid_arity, Qerror_message,
-        build_pure_c_string ("Invalid function arity"));
+        build_string ("Invalid function arity"));
  DEFSYM (Qmodule_function_p, "module-function-p");
  DEFSYM (Qunicode_string_p, "unicode-string-p");
diff --git a/src/emacs.c b/src/emacs.c
index 3c768412818..27bb04094a3 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -104,7 +104,6 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include "syntax.h"
 #include "sysselect.h"
 #include "systime.h"
-#include "puresize.h"
 #include "getpagesize.h"
 #include "gnutls.h"
@@ -3029,8 +3028,6 @@ You must run Emacs in batch mode in order to dump it.  */)
  Lisp_Object symbol;
  specpdl_ref count = SPECPDL_INDEX ();
-  check_pure_size ();
  if (! noninteractive)
    error ("Dumping Emacs works only in batch mode");
diff --git a/src/eval.c b/src/eval.c
index 141d2546f08..93cd02b023a 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -748,8 +748,6 @@ value.  */)
  XSYMBOL (symbol)->u.s.declared_special = true;
  if (!NILP (doc))
    {
-      if (!NILP (Vpurify_flag))
-        doc = Fpurecopy (doc);
      Fput (symbol, Qvariable_documentation, doc);
    }
  LOADHIST_ATTACH (symbol);
@@ -892,8 +890,6 @@ More specifically, behaves like (defconst SYM 'INITVALUE DOCSTRING).  */)
  CHECK_SYMBOL (sym);
  Lisp_Object tem = initvalue;
  Finternal__define_uninitialized_variable (sym, docstring);
-  if (!NILP (Vpurify_flag))
-    tem = Fpurecopy (tem);
  Fset_default (sym, tem);      /* FIXME: set-default-toplevel-value? */
  Fput (sym, Qrisky_local_variable, Qt); /* FIXME: Why?  */
  return sym;
@@ -2195,12 +2191,6 @@ this does nothing and returns nil.  */)
      && !AUTOLOADP (XSYMBOL (function)->u.s.function))
    return Qnil;
-  if (!NILP (Vpurify_flag) && BASE_EQ (docstring, make_fixnum (0)))
-    /* `read1' in lread.c has found the docstring starting with "\
-       and assumed the docstring will be provided by Snarf-documentation, so it
-       passed us 0 instead.  But that leads to accidental sharing in purecopy's
-       hash-consing, so we use a (hopefully) unique integer instead.  */
-    docstring = make_ufixnum (XHASH (function));
  return Fdefalias (function,
                    list5 (Qautoload, file, docstring, interactive, type),
                    Qnil);
@@ -4360,7 +4350,7 @@ alist of active lexical bindings.  */);
     also use something like Fcons (Qnil, Qnil), but json.c treats any
     cons cell as error data, so use an uninterned symbol instead.  */
  Qcatch_all_memory_full
-    = Fmake_symbol (build_pure_c_string ("catch-all-memory-full"));
+    = Fmake_symbol (build_string ("catch-all-memory-full"));
  defsubr (&Sor);
  defsubr (&Sand);
diff --git a/src/fileio.c b/src/fileio.c
index 10d4b8bc15e..bc5b4570c19 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -6462,39 +6462,39 @@ behaves as if file names were encoded in `utf-8'.  */);
  DEFSYM (Qcar_less_than_car, "car-less-than-car");
  Fput (Qfile_error, Qerror_conditions,
-        Fpurecopy (list2 (Qfile_error, Qerror)));
+        list2 (Qfile_error, Qerror));
  Fput (Qfile_error, Qerror_message,
-        build_pure_c_string ("File error"));
+        build_string ("File error"));
  Fput (Qfile_already_exists, Qerror_conditions,
-        Fpurecopy (list3 (Qfile_already_exists, Qfile_error, Qerror)));
+        list3 (Qfile_already_exists, Qfile_error, Qerror));
  Fput (Qfile_already_exists, Qerror_message,
-        build_pure_c_string ("File already exists"));
+        build_string ("File already exists"));
  Fput (Qfile_date_error, Qerror_conditions,
-        Fpurecopy (list3 (Qfile_date_error, Qfile_error, Qerror)));
+        list3 (Qfile_date_error, Qfile_error, Qerror));
  Fput (Qfile_date_error, Qerror_message,
-        build_pure_c_string ("Cannot set file date"));
+        build_string ("Cannot set file date"));
  Fput (Qfile_missing, Qerror_conditions,
-        Fpurecopy (list3 (Qfile_missing, Qfile_error, Qerror)));
+        list3 (Qfile_missing, Qfile_error, Qerror));
  Fput (Qfile_missing, Qerror_message,
-        build_pure_c_string ("File is missing"));
+        build_string ("File is missing"));
  Fput (Qpermission_denied, Qerror_conditions,
-        Fpurecopy (list3 (Qpermission_denied, Qfile_error, Qerror)));
+        list3 (Qpermission_denied, Qfile_error, Qerror));
  Fput (Qpermission_denied, Qerror_message,
-        build_pure_c_string ("Cannot access file or directory"));
+        build_string ("Cannot access file or directory"));
  Fput (Qfile_notify_error, Qerror_conditions,
-        Fpurecopy (list3 (Qfile_notify_error, Qfile_error, Qerror)));
+        list3 (Qfile_notify_error, Qfile_error, Qerror));
  Fput (Qfile_notify_error, Qerror_message,
-        build_pure_c_string ("File notification error"));
+        build_string ("File notification error"));
  Fput (Qremote_file_error, Qerror_conditions,
-        Fpurecopy (list3 (Qremote_file_error, Qfile_error, Qerror)));
+        list3 (Qremote_file_error, Qfile_error, Qerror));
  Fput (Qremote_file_error, Qerror_message,
-        build_pure_c_string ("Remote file error"));
+        build_string ("Remote file error"));
  DEFVAR_LISP ("file-name-handler-alist", Vfile_name_handler_alist,
               doc: /* Alist of elements (REGEXP . HANDLER) for file names handled specially.
diff --git a/src/fns.c b/src/fns.c
index 7553a094468..0564dbec83c 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -36,7 +36,6 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include "buffer.h"
 #include "intervals.h"
 #include "window.h"
-#include "puresize.h"
 #include "gnutls.h"
 enum equal_kind { EQUAL_NO_QUIT, EQUAL_PLAIN, EQUAL_INCLUDING_PROPERTIES };
@@ -2653,7 +2652,6 @@ ARRAY is a vector, string, char-table, or bool-vector.  */)
      size = SCHARS (array);
      if (size != 0)
        {
-          CHECK_IMPURE (array, XSTRING (array));
          unsigned char str[MAX_MULTIBYTE_LENGTH];
          int len;
          if (STRING_MULTIBYTE (array))
@@ -2695,7 +2693,6 @@ This makes STRING unibyte and may change its length.  */)
  ptrdiff_t len = SBYTES (string);
  if (len != 0 || STRING_MULTIBYTE (string))
    {
-      CHECK_IMPURE (string, XSTRING (string));
      memset (SDATA (string), 0, len);
      STRING_SET_CHARS (string, len);
      STRING_SET_UNIBYTE (string);
@@ -4263,16 +4260,12 @@ hash_index_size (struct Lisp_Hash_Table *h, ptrdiff_t size)
   size exceeds REHASH_THRESHOLD.
   WEAK specifies the weakness of the table.  If non-nil, it must be
-   one of the symbols `key', `value', `key-or-value', or `key-and-value'.
+   one of the symbols `key', `value', `key-or-value', or `key-and-value'. */
-   If PURECOPY is non-nil, the table can be copied to pure storage via
-   `purecopy' when Emacs is being dumped. Such tables can no longer be
-   changed after purecopy.  */
 Lisp_Object
 make_hash_table (struct hash_table_test test, EMACS_INT size,
                 float rehash_size, float rehash_threshold,
-                 Lisp_Object weak, bool purecopy)
+                 Lisp_Object weak)
 {
  struct Lisp_Hash_Table *h;
  Lisp_Object table;
@@ -4301,7 +4294,6 @@ make_hash_table (struct hash_table_test test, EMACS_INT size,
  h->next = make_vector (size, make_fixnum (-1));
  h->index = make_vector (hash_index_size (h, size), make_fixnum (-1));
  h->next_weak = NULL;
-  h->purecopy = purecopy;
  h->mutable = true;
  /* Set up the free list.  */
@@ -4402,11 +4394,6 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
            set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket));
            set_hash_index_slot (h, start_of_bucket, i);
          }
-#ifdef ENABLE_CHECKING
-      if (HASH_TABLE_P (Vpurify_flag) && XHASH_TABLE (Vpurify_flag) == h)
-        message ("Growing hash table to: %"pD"d", next_size);
-#endif
    }
 }
@@ -4470,7 +4457,6 @@ check_mutable_hash_table (Lisp_Object obj, struct Lisp_Hash_Table *h)
 {
  if (!h->mutable)
    signal_error ("hash table test modifies table", obj);
-  eassert (!PURE_P (h));
 }
 static void
@@ -4998,16 +4984,10 @@ key, value, one of key or value, or both key and value, depending on
 WEAK.  WEAK t is equivalent to `key-and-value'.  Default value of WEAK
 is nil.
-:purecopy PURECOPY -- If PURECOPY is non-nil, the table can be copied
-to pure storage when Emacs is being dumped, making the contents of the
-table read only. Any further changes to purified tables will result
-in an error.
 usage: (make-hash-table &rest KEYWORD-ARGS)  */)
  (ptrdiff_t nargs, Lisp_Object *args)
 {
  Lisp_Object test, weak;
-  bool purecopy;
  struct hash_table_test testdesc;
  ptrdiff_t i;
  USE_SAFE_ALLOCA;
@@ -5041,9 +5021,9 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
      testdesc.cmpfn = cmpfn_user_defined;
    }
-  /* See if there's a `:purecopy PURECOPY' argument.  */
+  /* Ignore a `:purecopy PURECOPY' argument.  We used to accept those, but
-  i = get_key_arg (QCpurecopy, nargs, args, used);
+     they were only meaningful when we had the purespace. */
-  purecopy = i && !NILP (args[i]);
+  get_key_arg (QCpurecopy, nargs, args, used);
  /* See if there's a `:size SIZE' argument.  */
  i = get_key_arg (QCsize, nargs, args, used);
  Lisp_Object size_arg = i ? args[i] : Qnil;
@@ -5093,8 +5073,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
      signal_error ("Invalid argument list", args[i]);
  SAFE_FREE ();
-  return make_hash_table (testdesc, size, rehash_size, rehash_threshold, weak,
+  return make_hash_table (testdesc, size, rehash_size, rehash_threshold, weak);
-                          purecopy);
 }
diff --git a/src/fontset.c b/src/fontset.c
index 1793715450e..2e3f6e096f6 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -2138,7 +2138,7 @@ syms_of_fontset (void)
  set_fontset_id (Vdefault_fontset, make_fixnum (0));
  set_fontset_name
    (Vdefault_fontset,
-     build_pure_c_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default"));
+     build_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default"));
  ASET (Vfontset_table, 0, Vdefault_fontset);
  next_fontset_id = 1;
  PDUMPER_REMEMBER_SCALAR (next_fontset_id);
@@ -2196,7 +2196,7 @@ alternate fontnames (if any) are tried instead.  */);
               doc: /* Alist of fontset names vs the aliases.  */);
  Vfontset_alias_alist
    = list1 (Fcons (FONTSET_NAME (Vdefault_fontset),
-                    build_pure_c_string ("fontset-default")));
+                    build_string ("fontset-default")));
  DEFVAR_LISP ("vertical-centering-font-regexp",
               Vvertical_centering_font_regexp,
diff --git a/src/frame.c b/src/frame.c
index 02c90ea6519..055edeb7b63 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -1028,7 +1028,7 @@ make_frame (bool mini_p)
  fset_face_hash_table
    (f, make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE, DEFAULT_REHASH_SIZE,
-                         DEFAULT_REHASH_THRESHOLD, Qnil, false));
+                         DEFAULT_REHASH_THRESHOLD, Qnil));
  if (mini_p)
    {
@@ -1192,7 +1192,7 @@ make_initial_frame (void)
  Vframe_list = Fcons (frame, Vframe_list);
  tty_frame_count = 1;
-  fset_name (f, build_pure_c_string ("F1"));
+  fset_name (f, build_string ("F1"));
  SET_FRAME_VISIBLE (f, 1);
diff --git a/src/image.c b/src/image.c
index c0a7b85cb3b..bdfe390dc44 100644
--- a/src/image.c
+++ b/src/image.c
@@ -5442,7 +5442,7 @@ xpm_make_color_table_h (void (**put_func) (Lisp_Object, const char *, int,
  *get_func = xpm_get_color_table_h;
  return make_hash_table (hashtest_equal, DEFAULT_HASH_SIZE,
                          DEFAULT_REHASH_SIZE, DEFAULT_REHASH_THRESHOLD,
-                          Qnil, false);
+                          Qnil);
 }
 static void
diff --git a/src/intervals.c b/src/intervals.c
index 85152c58a5d..136dc539a74 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -44,7 +44,6 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "intervals.h"
 #include "buffer.h"
-#include "puresize.h"
 #include "keymap.h"
 /* Test for membership, allowing for t (actually any non-cons) to mean the
@@ -101,7 +100,6 @@ create_root_interval (Lisp_Object parent)
    }
  else
    {
-      CHECK_IMPURE (parent, XSTRING (parent));
      new->total_length = SCHARS (parent);
      eassert (TOTAL_LENGTH (new) >= 0);
      set_string_intervals (parent, new);
diff --git a/src/json.c b/src/json.c
index 763f463aa4e..d30e82d8164 100644
--- a/src/json.c
+++ b/src/json.c
@@ -1102,8 +1102,8 @@ define_error (Lisp_Object name, const char *message, Lisp_Object parent)
  eassert (CONSP (parent_conditions));
  eassert (!NILP (Fmemq (parent, parent_conditions)));
  eassert (NILP (Fmemq (name, parent_conditions)));
-  Fput (name, Qerror_conditions, pure_cons (name, parent_conditions));
+  Fput (name, Qerror_conditions, Fcons (name, parent_conditions));
-  Fput (name, Qerror_message, build_pure_c_string (message));
+  Fput (name, Qerror_message, build_string (message));
 }
 void
diff --git a/src/keyboard.c b/src/keyboard.c
index 4cac20eb4b7..402d1035c9e 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -12045,14 +12045,14 @@ syms_of_keyboard (void)
  pending_funcalls = Qnil;
  staticpro (&pending_funcalls);
-  Vlispy_mouse_stem = build_pure_c_string ("mouse");
+  Vlispy_mouse_stem = build_string ("mouse");
  staticpro (&Vlispy_mouse_stem);
-  regular_top_level_message = build_pure_c_string ("Back to top level");
+  regular_top_level_message = build_string ("Back to top level");
  staticpro (&regular_top_level_message);
 #ifdef HAVE_STACK_OVERFLOW_HANDLING
  recover_top_level_message
-    = build_pure_c_string ("Re-entering top level after C stack overflow");
+    = build_string ("Re-entering top level after C stack overflow");
  staticpro (&recover_top_level_message);
 #endif
  DEFVAR_LISP ("internal--top-level-message", Vinternal__top_level_message,
diff --git a/src/keymap.c b/src/keymap.c
index 2b77a7fc444..c6188a251cb 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -50,7 +50,6 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include "keyboard.h"
 #include "termhooks.h"
 #include "blockinput.h"
-#include "puresize.h"
 #include "intervals.h"
 #include "keymap.h"
 #include "window.h"
@@ -121,8 +120,6 @@ in case you use it as a menu with `x-popup-menu'.  */)
 {
  if (!NILP (string))
    {
-      if (!NILP (Vpurify_flag))
-        string = Fpurecopy (string);
      return list2 (Qkeymap, string);
    }
  return list1 (Qkeymap);
@@ -301,7 +298,6 @@ Return PARENT.  PARENT should be nil or another keymap.  */)
         If we came to the end, add the parent in PREV.  */
      if (!CONSP (list) || KEYMAPP (list))
        {
-          CHECK_IMPURE (prev, XCONS (prev));
          XSETCDR (prev, parent);
          return parent;
        }
@@ -744,7 +740,7 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx,
  /* If we are preparing to dump, and DEF is a menu element
     with a menu item indicator, copy it to ensure it is not pure.  */
-  if (CONSP (def) && PURE_P (XCONS (def))
+  if (CONSP (def)
      && (EQ (XCAR (def), Qmenu_item) || STRINGP (XCAR (def))))
    def = Fcons (XCAR (def), XCDR (def));
@@ -788,7 +784,6 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx,
          {
            if (FIXNATP (idx) && XFIXNAT (idx) < ASIZE (elt))
              {
-                CHECK_IMPURE (elt, XVECTOR (elt));
                ASET (elt, XFIXNAT (idx), def);
                return def;
              }
@@ -846,7 +841,6 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx,
              }
            else if (EQ (idx, XCAR (elt)))
              {
-                CHECK_IMPURE (elt, XCONS (elt));
                if (remove)
                  /* Remove the element. */
                  insertion_point = Fdelq (elt, insertion_point);
@@ -900,7 +894,6 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx,
        }
      else
        elt = Fcons (idx, def);
-      CHECK_IMPURE (insertion_point, XCONS (insertion_point));
      XSETCDR (insertion_point, Fcons (elt, XCDR (insertion_point)));
    }
  }
@@ -3340,12 +3333,12 @@ syms_of_keymap (void)
  current_global_map = Qnil;
  staticpro (&current_global_map);
-  exclude_keys = pure_list
+  exclude_keys = list
-    (pure_cons (build_pure_c_string ("DEL"), build_pure_c_string ("\\d")),
+    (Fcons (build_string ("DEL"), build_string ("\\d")),
-     pure_cons (build_pure_c_string ("TAB"), build_pure_c_string ("\\t")),
+     Fcons (build_string ("TAB"), build_string ("\\t")),
-     pure_cons (build_pure_c_string ("RET"), build_pure_c_string ("\\r")),
+     Fcons (build_string ("RET"), build_string ("\\r")),
-     pure_cons (build_pure_c_string ("ESC"), build_pure_c_string ("\\e")),
+     Fcons (build_string ("ESC"), build_string ("\\e")),
-     pure_cons (build_pure_c_string ("SPC"), build_pure_c_string (" ")));
+     Fcons (build_string ("SPC"), build_string (" ")));
  staticpro (&exclude_keys);
  DEFVAR_LISP ("minibuffer-local-map", Vminibuffer_local_map,
@@ -3407,13 +3400,13 @@ that describe key bindings.  That is why the default is nil.  */);
  DEFSYM (Qmode_line, "mode-line");
  staticpro (&Vmouse_events);
-  Vmouse_events = pure_list (Qmenu_bar, Qtab_bar, Qtool_bar,
+  Vmouse_events = list (Qmenu_bar, Qtab_bar, Qtool_bar, Qtab_line,
-                             Qtab_line, Qheader_line, Qmode_line,
+                        Qheader_line, Qmode_line,
-                             intern_c_string ("mouse-1"),
+                        intern_c_string ("mouse-1"),
-                             intern_c_string ("mouse-2"),
+                        intern_c_string ("mouse-2"),
-                             intern_c_string ("mouse-3"),
+                        intern_c_string ("mouse-3"),
-                             intern_c_string ("mouse-4"),
+                        intern_c_string ("mouse-4"),
-                             intern_c_string ("mouse-5"));
+                        intern_c_string ("mouse-5"));
  /* Keymap used for minibuffers when doing completion.  */
  /* Keymap used for minibuffers when doing completion and require a match.  */
diff --git a/src/lisp.h b/src/lisp.h
index 7a7d2e79979..7be2e5d38dc 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -859,9 +859,6 @@ struct Lisp_Symbol
         special (with `defvar' etc), and shouldn't be lexically bound.  */
      bool_bf declared_special : 1;
-      /* True if pointed to from purespace and hence can't be GC'd.  */
-      bool_bf pinned : 1;
      /* The symbol's name, as a Lisp string.  */
      Lisp_Object name;
@@ -2426,12 +2423,8 @@ struct Lisp_Hash_Table
  /* Index of first free entry in free list, or -1 if none.  */
  ptrdiff_t next_free;
-  /* True if the table can be purecopied.  The table cannot be
-     changed afterwards.  */
-  bool purecopy;
  /* True if the table is mutable.  Ordinarily tables are mutable, but
-     pure tables are not, and while a table is being mutated it is
+     some tables are not, and while a table is being mutated it is
     immutable for recursive attempts to mutate it.  */
  bool mutable;
@@ -4010,7 +4003,7 @@ EMACS_UINT hash_string (char const *, ptrdiff_t);
 EMACS_UINT sxhash (Lisp_Object);
 Lisp_Object hashfn_user_defined (Lisp_Object, struct Lisp_Hash_Table *);
 Lisp_Object make_hash_table (struct hash_table_test, EMACS_INT, float, float,
-                             Lisp_Object, bool);
+                             Lisp_Object);
 ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object *);
 ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
                    Lisp_Object);
@@ -4177,7 +4170,6 @@ extern void parse_str_as_multibyte (const unsigned char *, ptrdiff_t,
 /* Defined in alloc.c.  */
 extern void *my_heap_start (void);
-extern void check_pure_size (void);
 unsigned char *resize_string_data (Lisp_Object, ptrdiff_t, int, int);
 extern void malloc_warning (const char *);
 extern AVOID memory_full (size_t);
@@ -4236,11 +4228,8 @@ extern Lisp_Object list4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
 extern Lisp_Object list5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
                          Lisp_Object);
 extern Lisp_Object listn (ptrdiff_t, Lisp_Object, ...);
-extern Lisp_Object pure_listn (ptrdiff_t, Lisp_Object, ...);
 #define list(...) \
  listn (ARRAYELTS (((Lisp_Object []) {__VA_ARGS__})), __VA_ARGS__)
-#define pure_list(...) \
-  pure_listn (ARRAYELTS (((Lisp_Object []) {__VA_ARGS__})), __VA_ARGS__)
 enum gc_root_type
 {
@@ -4313,18 +4302,8 @@ extern Lisp_Object make_uninit_multibyte_string (EMACS_INT, EMACS_INT);
 extern Lisp_Object make_string_from_bytes (const char *, ptrdiff_t, ptrdiff_t);
 extern Lisp_Object make_specified_string (const char *,
                                          ptrdiff_t, ptrdiff_t, bool);
-extern Lisp_Object make_pure_string (const char *, ptrdiff_t, ptrdiff_t, bool);
-extern Lisp_Object make_pure_c_string (const char *, ptrdiff_t);
 extern void pin_string (Lisp_Object string);
-/* Make a string allocated in pure space, use STR as string data.  */
-INLINE Lisp_Object
-build_pure_c_string (const char *str)
-{
-  return make_pure_c_string (str, strlen (str));
-}
 /* Make a string from the data at STR, treating it as multibyte if the
   data warrants.  */
@@ -4334,7 +4313,6 @@ build_string (const char *str)
  return make_string (str, strlen (str));
 }
-extern Lisp_Object pure_cons (Lisp_Object, Lisp_Object);
 extern Lisp_Object make_vector (ptrdiff_t, Lisp_Object);
 extern struct Lisp_Vector *allocate_nil_vector (ptrdiff_t)
  ATTRIBUTE_RETURNS_NONNULL;
diff --git a/src/lread.c b/src/lread.c
index 66b13916465..ada20810c3a 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1537,7 +1537,7 @@ Return t if the file exists and loads successfully.  */)
    }
  if (! NILP (Vpurify_flag))
-    Vpreloaded_file_list = Fcons (Fpurecopy (file), Vpreloaded_file_list);
+    Vpreloaded_file_list = Fcons (file, Vpreloaded_file_list);
  if (NILP (nomessage) || force_load_messages)
    {
@@ -2288,36 +2288,32 @@ readevalloop (Lisp_Object readcharfun,
        read_objects_map
          = make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE,
                             DEFAULT_REHASH_SIZE, DEFAULT_REHASH_THRESHOLD,
-                             Qnil, false);
+                             Qnil);
      if (! HASH_TABLE_P (read_objects_completed)
          || XHASH_TABLE (read_objects_completed)->count)
        read_objects_completed
          = make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE,
                             DEFAULT_REHASH_SIZE, DEFAULT_REHASH_THRESHOLD,
-                             Qnil, false);
+                             Qnil);
-      if (!NILP (Vpurify_flag) && c == '(')
+      if (!NILP (readfun))
-        val = read0 (readcharfun, false);
-      else
        {
-          if (!NILP (readfun))
+          val = call1 (readfun, readcharfun);
-            {
-              val = call1 (readfun, readcharfun);
-              /* If READCHARFUN has set point to ZV, we should
+          /* If READCHARFUN has set point to ZV, we should
                 stop reading, even if the form read sets point
                 to a different value when evaluated.  */
-              if (BUFFERP (readcharfun))
+          if (BUFFERP (readcharfun))
-                {
+            {
-                  struct buffer *buf = XBUFFER (readcharfun);
+              struct buffer *buf = XBUFFER (readcharfun);
-                  if (BUF_PT (buf) == BUF_ZV (buf))
+              if (BUF_PT (buf) == BUF_ZV (buf))
-                    continue_reading_p = 0;
+                continue_reading_p = 0;
-                }
            }
-          else if (! NILP (Vload_read_function))
-            val = call1 (Vload_read_function, readcharfun);
-          else
-            val = read_internal_start (readcharfun, Qnil, Qnil, false);
        }
+      else if (! NILP (Vload_read_function))
+        val = call1 (Vload_read_function, readcharfun);
+      else
+        val = read_internal_start (readcharfun, Qnil, Qnil, false);
      /* Empty hashes can be reused; otherwise, reset on next call.  */
      if (HASH_TABLE_P (read_objects_map)
          && XHASH_TABLE (read_objects_map)->count > 0)
@@ -2539,12 +2535,12 @@ read_internal_start (Lisp_Object stream, Lisp_Object start, Lisp_Object end,
      || XHASH_TABLE (read_objects_map)->count)
    read_objects_map
      = make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE, DEFAULT_REHASH_SIZE,
-                         DEFAULT_REHASH_THRESHOLD, Qnil, false);
+                         DEFAULT_REHASH_THRESHOLD, Qnil);
  if (! HASH_TABLE_P (read_objects_completed)
      || XHASH_TABLE (read_objects_completed)->count)
    read_objects_completed
      = make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE, DEFAULT_REHASH_SIZE,
-                         DEFAULT_REHASH_THRESHOLD, Qnil, false);
+                         DEFAULT_REHASH_THRESHOLD, Qnil);
  if (STRINGP (stream)
      || ((CONSP (stream) && STRINGP (XCAR (stream)))))
@@ -4150,10 +4146,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
        if (uninterned_symbol)
          {
            Lisp_Object name
-              = (!NILP (Vpurify_flag)
+              = make_specified_string (read_buffer, nchars, nbytes, multibyte);
-                 ? make_pure_string (read_buffer, nchars, nbytes, multibyte)
-                 : make_specified_string (read_buffer, nchars, nbytes,
-                                          multibyte));
            result = Fmake_symbol (name);
          }
        else
@@ -4645,16 +4638,8 @@ intern_c_string_1 (const char *str, ptrdiff_t len)
  Lisp_Object tem = oblookup (obarray, str, len, len);
  if (!SYMBOLP (tem))
-    {
+      tem = intern_driver (make_string (str, len), obarray, tem);
-      Lisp_Object string;
-      if (NILP (Vpurify_flag))
-        string = make_string (str, len);
-      else
-        string = make_pure_c_string (str, len);
-      tem = intern_driver (string, obarray, tem);
-    }
  return tem;
 }
@@ -4662,7 +4647,7 @@ static void
 define_symbol (Lisp_Object sym, char const *str)
 {
  ptrdiff_t len = strlen (str);
-  Lisp_Object string = make_pure_c_string (str, len);
+  Lisp_Object string = make_string (str, len);
  init_symbol (sym, string);
  /* Qunbound is uninterned, so that it's not confused with any symbol
@@ -4706,8 +4691,7 @@ it defaults to the value of `obarray'.  */)
          xfree (longhand);
        }
      else
-        tem = intern_driver (NILP (Vpurify_flag) ? string : Fpurecopy (string),
+        tem = intern_driver (string, obarray, tem);
-                             obarray, tem);
    }
  return tem;
 }
@@ -5002,7 +4986,7 @@ init_obarray_once (void)
  XSYMBOL (Qt)->u.s.declared_special = true;
  /* Qt is correct even if not dumping.  loadup.el will set to nil at end.  */
-  Vpurify_flag = Qt;
+  Vpurify_flag = Qt;  /* FIXME: Redundant with setting in alloc.c.  */
  DEFSYM (Qvariable_documentation, "variable-documentation");
 }
@@ -5019,7 +5003,7 @@ defsubr (union Aligned_Lisp_Subr *aname)
  set_symbol_function (sym, tem);
 #ifdef HAVE_NATIVE_COMP
  eassert (NILP (Vcomp_abi_hash));
-  Vcomp_subr_list = Fpurecopy (Fcons (tem, Vcomp_subr_list));
+  Vcomp_subr_list = Fcons (tem, Vcomp_subr_list);
 #endif
 }
@@ -5412,20 +5396,20 @@ This list includes suffixes for both compiled and source Emacs Lisp files.
 This list should not include the empty string.
 `load' and related functions try to append these suffixes, in order,
 to the specified file name if a suffix is allowed or required.  */);
-  Vload_suffixes = list2 (build_pure_c_string (".elc"),
+  Vload_suffixes = list2 (build_string (".elc"),
-                          build_pure_c_string (".el"));
+                          build_string (".el"));
 #ifdef HAVE_MODULES
-  Vload_suffixes = Fcons (build_pure_c_string (MODULES_SUFFIX), Vload_suffixes);
+  Vload_suffixes = Fcons (build_string (MODULES_SUFFIX), Vload_suffixes);
 #ifdef MODULES_SECONDARY_SUFFIX
  Vload_suffixes =
-    Fcons (build_pure_c_string (MODULES_SECONDARY_SUFFIX), Vload_suffixes);
+    Fcons (build_string (MODULES_SECONDARY_SUFFIX), Vload_suffixes);
 #endif
 #endif
  DEFVAR_LISP ("module-file-suffix", Vmodule_file_suffix,
               doc: /* Suffix of loadable module file, or nil if modules are not supported.  */);
 #ifdef HAVE_MODULES
-  Vmodule_file_suffix = build_pure_c_string (MODULES_SUFFIX);
+  Vmodule_file_suffix = build_string (MODULES_SUFFIX);
 #else
  Vmodule_file_suffix = Qnil;
 #endif
@@ -5575,7 +5559,7 @@ from the file, and matches them against this regular expression.
 When the regular expression matches, the file is considered to be safe
 to load.  */);
  Vbytecomp_version_regexp
-    = build_pure_c_string ("^;;;.\\(in Emacs version\\|bytecomp version FSF\\)");
+    = build_string ("^;;;.\\(in Emacs version\\|bytecomp version FSF\\)");
  DEFSYM (Qlexical_binding, "lexical-binding");
  DEFVAR_LISP ("lexical-binding", Vlexical_binding,
diff --git a/src/pdumper.c b/src/pdumper.c
index af451920eb6..38275d39bd8 100644
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -2412,7 +2412,7 @@ dump_symbol (struct dump_context *ctx,
             Lisp_Object object,
             dump_off offset)
 {
-#if CHECK_STRUCTS && !defined HASH_Lisp_Symbol_999DC26DEC
+#if CHECK_STRUCTS && !defined HASH_Lisp_Symbol_DD2E6013B4
 # error "Lisp_Symbol changed. See CHECK_STRUCTS comment in config.h."
 #endif
 #if CHECK_STRUCTS && !defined (HASH_symbol_redirect_ADB4F5B113)
@@ -2449,7 +2449,6 @@ dump_symbol (struct dump_context *ctx,
  DUMP_FIELD_COPY (&out, symbol, u.s.trapped_write);
  DUMP_FIELD_COPY (&out, symbol, u.s.interned);
  DUMP_FIELD_COPY (&out, symbol, u.s.declared_special);
-  DUMP_FIELD_COPY (&out, symbol, u.s.pinned);
  dump_field_lv (ctx, &out, symbol, &symbol->u.s.name, WEIGHT_STRONG);
  switch (symbol->u.s.redirect)
    {
@@ -2666,7 +2665,7 @@ dump_hash_table (struct dump_context *ctx,
                 Lisp_Object object,
                 dump_off offset)
 {
-#if CHECK_STRUCTS && !defined HASH_Lisp_Hash_Table_6D63EDB618
+#if CHECK_STRUCTS && !defined HASH_Lisp_Hash_Table_203821C7EF
 # error "Lisp_Hash_Table changed. See CHECK_STRUCTS comment in config.h."
 #endif
  const struct Lisp_Hash_Table *hash_in = XHASH_TABLE (object);
@@ -2682,7 +2681,6 @@ dump_hash_table (struct dump_context *ctx,
     them as close to the hash table as possible.  */
  DUMP_FIELD_COPY (out, hash, count);
  DUMP_FIELD_COPY (out, hash, next_free);
-  DUMP_FIELD_COPY (out, hash, purecopy);
  DUMP_FIELD_COPY (out, hash, mutable);
  DUMP_FIELD_COPY (out, hash, rehash_threshold);
  DUMP_FIELD_COPY (out, hash, rehash_size);
diff --git a/src/print.c b/src/print.c
index d562500b619..bc17cee0ed4 100644
--- a/src/print.c
+++ b/src/print.c
@@ -2509,9 +2509,6 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
            print_object (Fhash_table_rehash_threshold (obj),
                          printcharfun, escapeflag);
-            if (h->purecopy)
-              print_c_string (" purecopy t", printcharfun);
            print_c_string (" data (", printcharfun);
            ptrdiff_t size = h->count;
diff --git a/src/process.c b/src/process.c
index af402c8edb3..73bb805dcb5 100644
--- a/src/process.c
+++ b/src/process.c
@@ -8750,7 +8750,7 @@ sentinel or a process filter function has an error.  */);
   const struct socket_options *sopt;
 #define ADD_SUBFEATURE(key, val) \
-  subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
+  subfeatures = Fcons (Fcons (key, Fcons (val, Qnil)), subfeatures)
   ADD_SUBFEATURE (QCnowait, Qt);
 #ifdef DATAGRAM_SOCKETS
@@ -8772,7 +8772,7 @@ sentinel or a process filter function has an error.  */);
   ADD_SUBFEATURE (QCserver, Qt);
   for (sopt = socket_options; sopt->name; sopt++)
-     subfeatures = pure_cons (intern_c_string (sopt->name), subfeatures);
+     subfeatures = Fcons (intern_c_string (sopt->name), subfeatures);
   Fprovide (intern_c_string ("make-network-process"), subfeatures);
 }
diff --git a/src/profiler.c b/src/profiler.c
index 5cb42d54fa6..dc28b3c25ad 100644
--- a/src/profiler.c
+++ b/src/profiler.c
@@ -63,7 +63,7 @@ make_log (void)
  Lisp_Object log = make_hash_table (hashtest_profiler, heap_size,
                                     DEFAULT_REHASH_SIZE,
                                     DEFAULT_REHASH_THRESHOLD,
-                                     Qnil, false);
+                                     Qnil);
  struct Lisp_Hash_Table *h = XHASH_TABLE (log);
  /* What is special about our hash-tables is that the values are pre-filled
diff --git a/src/puresize.h b/src/puresize.h
deleted file mode 100644
index 5516747ac2b..00000000000
--- a/src/puresize.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/* How much read-only Lisp storage a dumped Emacs needs.
-   Copyright (C) 1993, 2001-2022 Free Software Foundation, Inc.
-This file is part of GNU Emacs.
-GNU Emacs is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or (at
-your option) any later version.
-GNU Emacs is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
-#ifndef EMACS_PURESIZE_H
-#define EMACS_PURESIZE_H
-#include "lisp.h"
-INLINE_HEADER_BEGIN
-/* Define PURESIZE, the number of bytes of pure Lisp code to leave space for.
-   At one point, this was defined in config.h, meaning that changing
-   PURESIZE would make Make recompile all of Emacs.  But only a few
-   files actually use PURESIZE, so we split it out to its own .h file.
-   Make sure to include this file after config.h, since that tells us
-   whether we are running X windows, which tells us how much pure
-   storage to allocate.  */
-/* First define a measure of the amount of data we have.  */
-/* A system configuration file may set this to request a certain extra
-   amount of storage.  This is a lot more update-robust that defining
-   BASE_PURESIZE or even PURESIZE directly.  */
-#ifndef SYSTEM_PURESIZE_EXTRA
-#define SYSTEM_PURESIZE_EXTRA 0
-#endif
-#ifndef SITELOAD_PURESIZE_EXTRA
-#define SITELOAD_PURESIZE_EXTRA 0
-#endif
-#ifndef BASE_PURESIZE
-#define BASE_PURESIZE (2000000 + SYSTEM_PURESIZE_EXTRA + SITELOAD_PURESIZE_EXTRA)
-#endif
-/* Increase BASE_PURESIZE by a ratio depending on the machine's word size.  */
-#ifndef PURESIZE_RATIO
-#if EMACS_INT_MAX >> 31 != 0
-#if PTRDIFF_MAX >> 31 != 0
-#define PURESIZE_RATIO 10 / 6   /* Don't surround with `()'.  */
-#else
-#define PURESIZE_RATIO 8 / 6    /* Don't surround with `()'.  */
-#endif
-#else
-#define PURESIZE_RATIO 1
-#endif
-#endif
-#ifdef ENABLE_CHECKING
-/* ENABLE_CHECKING somehow increases the purespace used, probably because
-   it tends to cause some macro arguments to be evaluated twice.  This is
-   a bug, but it's difficult to track it down.  */
-#define PURESIZE_CHECKING_RATIO 12 / 10 /* Don't surround with `()'.  */
-#else
-#define PURESIZE_CHECKING_RATIO 1
-#endif
-/* This is the actual size in bytes to allocate.  */
-#ifndef PURESIZE
-#define PURESIZE  (BASE_PURESIZE * PURESIZE_RATIO * PURESIZE_CHECKING_RATIO)
-#endif
-extern AVOID pure_write_error (Lisp_Object);
-extern EMACS_INT pure[];
-/* The puresize_h_* macros are private to this include file.  */
-/* True if PTR is pure.  */
-#define puresize_h_PURE_P(ptr) \
-  ((uintptr_t) (ptr) - (uintptr_t) pure <= PURESIZE)
-INLINE bool
-PURE_P (void *ptr)
-{
-  return puresize_h_PURE_P (ptr);
-}
-/* Signal an error if OBJ is pure.  PTR is OBJ untagged.  */
-#define puresize_h_CHECK_IMPURE(obj, ptr) \
-  (PURE_P (ptr) ? pure_write_error (obj) : (void) 0)
-INLINE void
-CHECK_IMPURE (Lisp_Object obj, void *ptr)
-{
-  puresize_h_CHECK_IMPURE (obj, ptr);
-}
-#if DEFINE_KEY_OPS_AS_MACROS
-# define PURE_P(ptr) puresize_h_PURE_P (ptr)
-# define CHECK_IMPURE(obj, ptr) puresize_h_CHECK_IMPURE (obj, ptr)
-#endif
-INLINE_HEADER_END
-#endif /* EMACS_PURESIZE_H */
diff --git a/src/search.c b/src/search.c
index 9d6bd074e1b..c8e0443500e 100644
--- a/src/search.c
+++ b/src/search.c
@@ -3385,19 +3385,19 @@ syms_of_search (void)
  DEFSYM (Qinvalid_regexp, "invalid-regexp");
  Fput (Qsearch_failed, Qerror_conditions,
-        pure_list (Qsearch_failed, Qerror));
+        list (Qsearch_failed, Qerror));
  Fput (Qsearch_failed, Qerror_message,
-        build_pure_c_string ("Search failed"));
+        build_string ("Search failed"));
  Fput (Quser_search_failed, Qerror_conditions,
-        pure_list (Quser_search_failed, Quser_error, Qsearch_failed, Qerror));
+        list (Quser_search_failed, Quser_error, Qsearch_failed, Qerror));
  Fput (Quser_search_failed, Qerror_message,
-        build_pure_c_string ("Search failed"));
+        build_string ("Search failed"));
  Fput (Qinvalid_regexp, Qerror_conditions,
-        pure_list (Qinvalid_regexp, Qerror));
+        list (Qinvalid_regexp, Qerror));
  Fput (Qinvalid_regexp, Qerror_message,
-        build_pure_c_string ("Invalid regexp"));
+        build_string ("Invalid regexp"));
  re_match_object = Qnil;
  staticpro (&re_match_object);
diff --git a/src/sqlite.c b/src/sqlite.c
index 75a3b2ea32c..6bc4b280844 100644
--- a/src/sqlite.c
+++ b/src/sqlite.c
@@ -769,9 +769,9 @@ syms_of_sqlite (void)
  DEFSYM (Qsqlite_locked_error, "sqlite-locked-error");
  Fput (Qsqlite_locked_error, Qerror_conditions,
-        Fpurecopy (list2 (Qsqlite_locked_error, Qerror)));
+        list2 (Qsqlite_locked_error, Qerror));
  Fput (Qsqlite_locked_error, Qerror_message,
-        build_pure_c_string ("Database locked"));
+        build_string ("Database locked"));
  DEFSYM (Qsqlitep, "sqlitep");
  DEFSYM (Qfalse, "false");
diff --git a/src/syntax.c b/src/syntax.c
index 15625b4d0e2..50e69ef2295 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -3750,9 +3750,9 @@ syms_of_syntax (void)
  DEFSYM (Qscan_error, "scan-error");
  Fput (Qscan_error, Qerror_conditions,
-        pure_list (Qscan_error, Qerror));
+        list (Qscan_error, Qerror));
  Fput (Qscan_error, Qerror_message,
-        build_pure_c_string ("Scan error"));
+        build_string ("Scan error"));
  DEFVAR_BOOL ("parse-sexp-ignore-comments", parse_sexp_ignore_comments,
               doc: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace.  */);
diff --git a/src/w32fns.c b/src/w32fns.c
index 468073c9170..dfbc09386b9 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -10554,9 +10554,9 @@ syms_of_w32fns (void)
  DEFSYM (Qjson, "json");
  Fput (Qundefined_color, Qerror_conditions,
-        pure_list (Qundefined_color, Qerror));
+        list (Qundefined_color, Qerror));
  Fput (Qundefined_color, Qerror_message,
-        build_pure_c_string ("Undefined color"));
+        build_string ("Undefined color"));
  staticpro (&w32_grabbed_keys);
  w32_grabbed_keys = Qnil;
diff --git a/src/xdisp.c b/src/xdisp.c
index 4089525e10f..8c97242a134 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -36064,7 +36064,7 @@ See also `overlay-arrow-string'.  */);
  DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string,
    doc: /* String to display as an arrow in non-window frames.
 See also `overlay-arrow-position'.  */);
-  Voverlay_arrow_string = build_pure_c_string ("=>");
+  Voverlay_arrow_string = build_string ("=>");
  DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list,
    doc: /* List of variables (symbols) which hold markers for overlay arrows.
@@ -36194,17 +36194,17 @@ which no explicit name has been set (see `modify-frame-parameters').  */);
 This variable has the same structure as `mode-line-format' (which see),
 and is used only on frames for which no explicit name has been set
 \(see `modify-frame-parameters').  */);
-  /* Do not nest calls to pure_list.  This works around a bug in
+  /* Do not nest calls to list.  This works around a bug in
     Oracle Developer Studio 12.6.  */
  Lisp_Object icon_title_name_format
-    = pure_list (empty_unibyte_string,
+    = list (empty_unibyte_string,
-                 build_pure_c_string ("%b - GNU Emacs at "),
+            build_string ("%b - GNU Emacs at "),
-                 intern_c_string ("system-name"));
+            intern_c_string ("system-name"));
  Vicon_title_format
    = Vframe_title_format
-    = pure_list (intern_c_string ("multiple-frames"),
+    = list (intern_c_string ("multiple-frames"),
-                 build_pure_c_string ("%b"),
+            build_string ("%b"),
-                 icon_title_name_format);
+            icon_title_name_format);
  DEFVAR_LISP ("message-log-max", Vmessage_log_max,
    doc: /* Maximum number of lines to keep in the message log buffer.
diff --git a/src/xfaces.c b/src/xfaces.c
index f70fe87c95e..79e5df4bb7f 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -7122,14 +7122,14 @@ only for this purpose.  */);
  Vface_new_frame_defaults =
    /* 33 entries is enough to fit all basic faces */
    make_hash_table (hashtest_eq, 33, DEFAULT_REHASH_SIZE,
-                     DEFAULT_REHASH_THRESHOLD, Qnil, false);
+                     DEFAULT_REHASH_THRESHOLD, Qnil);
  DEFVAR_LISP ("face-default-stipple", Vface_default_stipple,
    doc: /* Default stipple pattern used on monochrome displays.
 This stipple pattern is used on monochrome displays
 instead of shades of gray for a face background color.
 See `set-face-stipple' for possible values for this variable.  */);
-  Vface_default_stipple = build_pure_c_string ("gray3");
+  Vface_default_stipple = build_string ("gray3");
  DEFVAR_LISP ("tty-defined-color-alist", Vtty_defined_color_alist,
   doc: /* An alist of defined terminal colors and their RGB values.
diff --git a/src/xfns.c b/src/xfns.c
index 9dcf73da1ca..b202d62c61e 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -9690,9 +9690,9 @@ syms_of_xfns (void)
  DEFSYM (QXdndActionPrivate, "XdndActionPrivate");
  Fput (Qundefined_color, Qerror_conditions,
-        pure_list (Qundefined_color, Qerror));
+        list (Qundefined_color, Qerror));
  Fput (Qundefined_color, Qerror_message,
-        build_pure_c_string ("Undefined color"));
+        build_string ("Undefined color"));
  DEFVAR_LISP ("x-pointer-shape", Vx_pointer_shape,
    doc: /* The shape of the pointer when over text.
@@ -9903,7 +9903,7 @@ eliminated in future versions of Emacs.  */);
    char gtk_version[sizeof ".." + 3 * INT_STRLEN_BOUND (int)];
    int len = sprintf (gtk_version, "%d.%d.%d",
                       GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
-    Vgtk_version_string = make_pure_string (gtk_version, len, len, false);
+    Vgtk_version_string = make_specified_string (gtk_version, len, len, false);
  }
 #endif /* USE_GTK */
@@ -9917,7 +9917,8 @@ eliminated in future versions of Emacs.  */);
    int len = sprintf (cairo_version, "%d.%d.%d",
                       CAIRO_VERSION_MAJOR, CAIRO_VERSION_MINOR,
                       CAIRO_VERSION_MICRO);
-    Vcairo_version_string = make_pure_string (cairo_version, len, len, false);
+    Vcairo_version_string = make_specified_string (cairo_version, len, len,
+                                                   false);
  }
 #endif
diff --git a/src/xterm.c b/src/xterm.c
index c83ddc6b9ea..ba299e854fc 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -27815,7 +27815,7 @@ syms_of_xterm (void)
  DEFSYM (Qx_dnd_targets_list, "x-dnd-targets-list");
 #ifdef USE_GTK
-  xg_default_icon_file = build_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
+  xg_default_icon_file = build_string ("icons/hicolor/scalable/apps/emacs.svg");
  staticpro (&xg_default_icon_file);
  DEFSYM (Qx_gtk_map_stock, "x-gtk-map-stock");
@@ -27950,7 +27950,7 @@ If set to a non-float value, there will be no wait at all.  */);
  Vx_keysym_table = make_hash_table (hashtest_eql, 900,
                                     DEFAULT_REHASH_SIZE,
                                     DEFAULT_REHASH_THRESHOLD,
-                                     Qnil, false);
+                                     Qnil);
  DEFVAR_BOOL ("x-frame-normalize-before-maximize",
               x_frame_normalize_before_maximize,