Re-port to 32-bit systems without alignment primitives

* configure.ac (ALIGNOF_INT, ALIGNOF_LONG, ALIGNOF_LONG_LONG):
New variables.
(emacs_cv_alignas_unavailable): Define if alignas and structure
alignment primitives are unavailable.  In such an environment,
the MSB tagging scheme must be enabled, as must the GNU malloc.

* msdos/sed2v2.inp: Adjust correspondingly.

* src/alloc.c (union emacs_align_type): Remove types which
contain flexible array members.  The address of a field
subsequent to an aggregate with flexible array members cannot
validly be taken.
(mark_memory) [!USE_LSB_TAG && !WIDE_EMACS_INT]: Strip type bits
before scanning memory.

* src/emacs.c (main):

* src/eval.c (Fautoload_do_load):

* src/fns.c (Frequire): Rename a number of illogically named
fields.

* src/lisp.h (ALIGNOF_EMACS_INT): Define to the natural
alignment of EMACS_INT.
(IDEAL_GCALIGNMENT): New macro.
(USE_LSB_TAG): Disable if no alignment specifiers are available,
WIDE_EMACS_INT is undefined, and the natural alignment of
EMACS_INT falls short of LSB tagging's requirements.
(gflags): Rename illogically named fields and don't define them
as bitfields, which runs afoul of certain compiler issues.
(will_dump_p, will_bootstrap_p, will_dump_with_pdumper_p)
(dumped_with_pdumper_p): Adjust accordingly.

* src/pdumper.c (VM_SUPPORTED): Define to 0 when !USE_LSB_TAG.
It is better to read dump files into the heap by hand than to be
supplied with an address that is not representable.
(_dump_object_start_pseudovector): Rename to
dump_object_start_pseudovector, to avoid encroaching on reserved
names.
(START_DUMP_PVEC): Adjust correspondingly.
(dump_mmap_contiguous_vm): Preserve errno around failure
cleanup.
(dump_bitset_bit_set_p): Work around certain compiler issues.
(pdumper_load) [!USE_LSB_TAG]: Reject dump file allocations
that are not representable as Lisp_Objects.

Tested on i386-unknown-solaris2.10, sparc-sun-solaris2.10.

1 files changed, 83 insertions, 58 deletions

diff --git a/src/pdumper.c b/src/pdumper.c
index 342c37b5e62..8e10e561bcf 100644
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -77,7 +77,9 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #define VM_POSIX 1
 #define VM_MS_WINDOWS 2
 
-#if defined (HAVE_MMAP) && defined (MAP_FIXED)
+#if !USE_LSB_TAG
+# define VM_SUPPORTED 0
+#elif defined (HAVE_MMAP) && defined (MAP_FIXED)
 # define VM_SUPPORTED VM_POSIX
 # if !defined (MAP_POPULATE) && defined (MAP_PREFAULT_READ)
 #  define MAP_POPULATE MAP_PREFAULT_READ
@@ -1964,9 +1966,9 @@ dump_field_emacs_ptr (struct dump_context *ctx,
 }
 
 static void
-_dump_object_start_pseudovector (struct dump_context *ctx,
-                                 union vectorlike_header *out_hdr,
-                                 const union vectorlike_header *in_hdr)
+dump_object_start_pseudovector (struct dump_context *ctx,
+                                union vectorlike_header *out_hdr,
+                                const union vectorlike_header *in_hdr)
 {
   eassert (in_hdr->size & PSEUDOVECTOR_FLAG);
   ptrdiff_t vec_size = vectorlike_nbytes (in_hdr);
@@ -1976,9 +1978,9 @@ _dump_object_start_pseudovector (struct dump_context *ctx,
 
 /* Need a macro for alloca.  */
 #define START_DUMP_PVEC(ctx, hdr, type, out)                  \
-  const union vectorlike_header *_in_hdr = (hdr);             \
-  type *out = alloca (vectorlike_nbytes (_in_hdr));           \
-  _dump_object_start_pseudovector (ctx, &out->header, _in_hdr)
+  const union vectorlike_header *in_hdr = (hdr);              \
+  type *out = alloca (vectorlike_nbytes (in_hdr));            \
+  dump_object_start_pseudovector (ctx, &out->header, in_hdr)
 
 static dump_off
 finish_dump_pvec (struct dump_context *ctx,
@@ -3994,14 +3996,14 @@ dump_do_fixup (struct dump_context *ctx,
                Lisp_Object fixup,
                Lisp_Object prev_fixup)
 {
-  enum dump_fixup_type type =
-    (enum dump_fixup_type) XFIXNUM (dump_pop (&fixup));
+  enum dump_fixup_type type
+    = (enum dump_fixup_type) XFIXNUM (dump_pop (&fixup));
   dump_off dump_fixup_offset = dump_off_from_lisp (dump_pop (&fixup));
 #ifdef ENABLE_CHECKING
   if (!NILP (prev_fixup))
     {
-      dump_off prev_dump_fixup_offset =
-        dump_off_from_lisp (XCAR (XCDR (prev_fixup)));
+      dump_off prev_dump_fixup_offset
+        = dump_off_from_lisp (XCAR (XCDR (prev_fixup)));
       eassert (dump_fixup_offset - prev_dump_fixup_offset
                >= sizeof (void *));
     }
@@ -4618,23 +4620,8 @@ dump_anonymous_allocate_posix (void *base,
 }
 #endif
 
-/* Perform anonymous memory allocation.  */
-static void *
-dump_anonymous_allocate (void *base,
-                         const size_t size,
-                         enum dump_memory_protection protection)
-{
-#if VM_SUPPORTED == VM_POSIX
-  return dump_anonymous_allocate_posix (base, size, protection);
-#elif VM_SUPPORTED == VM_MS_WINDOWS
-  return dump_anonymous_allocate_w32 (base, size, protection);
-#else
-  errno = ENOSYS;
-  return NULL;
-#endif
-}
+/* Undo the effect of `dump_reserve_address_space'.  */
 
-/* Undo the effect of dump_reserve_address_space().  */
 static void
 dump_anonymous_release (void *addr, size_t size)
 {
@@ -4653,6 +4640,26 @@ dump_anonymous_release (void *addr, size_t size)
 #endif
 }
 
+/* Perform anonymous memory allocation.  */
+static void *
+dump_anonymous_allocate (void *base,
+                         const size_t size,
+                         enum dump_memory_protection protection)
+{
+  void *val;
+
+#if VM_SUPPORTED == VM_POSIX
+  val = dump_anonymous_allocate_posix (base, size, protection);
+#elif VM_SUPPORTED == VM_MS_WINDOWS
+  val = dump_anonymous_allocate_w32 (base, size, protection);
+#else
+  errno = ENOSYS;
+  val = NULL;
+#endif
+
+  return val;
+}
+
 #if VM_SUPPORTED == VM_MS_WINDOWS
 static void *
 dump_map_file_w32 (void *base, int fd, off_t offset, size_t size,
@@ -4824,20 +4831,20 @@ static void
 dump_discard_mem (void *mem, size_t size)
 {
 #if VM_SUPPORTED == VM_MS_WINDOWS
-      /* Discard COWed pages.  */
-      (void) VirtualFree (mem, size, MEM_DECOMMIT);
-      /* Release the commit charge for the mapping.  */
-      DWORD old_prot;
-      (void) VirtualProtect (mem, size, PAGE_NOACCESS, &old_prot);
+  /* Discard COWed pages.  */
+  (void) VirtualFree (mem, size, MEM_DECOMMIT);
+  /* Release the commit charge for the mapping.  */
+  DWORD old_prot;
+  (void) VirtualProtect (mem, size, PAGE_NOACCESS, &old_prot);
 #elif VM_SUPPORTED == VM_POSIX
 # ifdef HAVE_POSIX_MADVISE
-      /* Discard COWed pages.  */
-      (void) posix_madvise (mem, size, POSIX_MADV_DONTNEED);
+  /* Discard COWed pages.  */
+  (void) posix_madvise (mem, size, POSIX_MADV_DONTNEED);
 # elif defined HAVE_MADVISE
-      (void) madvise (mem, size, MADV_DONTNEED);
+  (void) madvise (mem, size, MADV_DONTNEED);
 #endif
-      /* Release the commit charge for the mapping.  */
-      (void) mprotect (mem, size, PROT_NONE);
+  /* Release the commit charge for the mapping.  */
+  (void) mprotect (mem, size, PROT_NONE);
 #endif
 }
 
@@ -4959,21 +4966,23 @@ dump_mmap_release_vm (struct dump_memory_map *map)
 static bool
 needs_mmap_retry_p (void)
 {
-#if defined CYGWIN || VM_SUPPORTED == VM_MS_WINDOWS || defined _AIX
+#if defined CYGWIN || VM_SUPPORTED == VM_MS_WINDOWS \
+  || defined _AIX
   return true;
-#else
+#else /* !CYGWIN && VM_SUPPORTED != VM_MS_WINDOWS && !_AIX */
   return false;
-#endif
+#endif /* !CYGWIN && VM_SUPPORTED != VM_MS_WINDOWS && !_AIX */
 }
 
 static bool
 dump_mmap_contiguous_vm (struct dump_memory_map *maps, int nr_maps,
                          size_t total_size)
 {
+  int save_errno;
   bool ret = false;
   void *resv = NULL;
   bool retry = false;
-  const bool need_retry = needs_mmap_retry_p ();
+  bool need_retry = needs_mmap_retry_p ();
 
   do
     {
@@ -4986,11 +4995,10 @@ dump_mmap_contiguous_vm (struct dump_memory_map *maps, int nr_maps,
         }
 
       eassert (resv == NULL);
-      resv = dump_anonymous_allocate (NULL,
-                                      total_size,
+      resv = dump_anonymous_allocate (NULL, total_size,
                                       DUMP_MEMORY_ACCESS_NONE);
       if (!resv)
-        goto out;
+        goto out;
 
       char *mem = resv;
 
@@ -5039,6 +5047,7 @@ dump_mmap_contiguous_vm (struct dump_memory_map *maps, int nr_maps,
   ret = true;
   resv = NULL;
  out:
+  save_errno = errno;
   if (resv)
     dump_anonymous_release (resv, total_size);
   if (!ret)
@@ -5051,6 +5060,7 @@ dump_mmap_contiguous_vm (struct dump_memory_map *maps, int nr_maps,
             dump_mmap_release (&maps[i]);
         }
     }
+  errno = save_errno;
   return ret;
 }
 
@@ -5058,8 +5068,8 @@ dump_mmap_contiguous_vm (struct dump_memory_map *maps, int nr_maps,
 
    Each dump_memory_map structure describes how to fill the
    corresponding range of memory. On input, all members except MAPPING
-   are valid. On output, MAPPING contains the location of the given
-   chunk of memory. The MAPPING for MAPS[N] is MAPS[N-1].mapping +
+   are valid.  On output, MAPPING contains the location of the given
+   chunk of memory.  The MAPPING for MAPS[N] is MAPS[N-1].mapping +
    MAPS[N-1].size.
 
    Each mapping SIZE must be a multiple of the system page size except
@@ -5085,8 +5095,10 @@ dump_mmap_contiguous (struct dump_memory_map *maps, int nr_maps)
       total_size += maps[i].spec.size;
     }
 
-  return (VM_SUPPORTED ? dump_mmap_contiguous_vm : dump_mmap_contiguous_heap)
-    (maps, nr_maps, total_size);
+  if (VM_SUPPORTED)
+    return dump_mmap_contiguous_vm (maps, nr_maps, total_size);
+  else
+    return dump_mmap_contiguous_heap (maps, nr_maps, total_size);
 }
 
 typedef uint_fast32_t dump_bitset_word;
@@ -5129,7 +5141,7 @@ dump_bitset_bit_set_p (const struct dump_bitset *bitset,
 {
   dump_bitset_word bit = 1;
   bit <<= bit_number % DUMP_BITSET_WORD_WIDTH;
-  return *dump_bitset__bit_slot (bitset, bit_number) & bit;
+  return (*dump_bitset__bit_slot (bitset, bit_number) & bit) != 0;
 }
 
 static void
@@ -5548,8 +5560,8 @@ dump_do_dump_relocation (const uintptr_t dump_base,
         struct bignum_reload_info reload_info;
         static_assert (sizeof (reload_info) <= sizeof (*bignum_val (bignum)));
         memcpy (&reload_info, bignum_val (bignum), sizeof (reload_info));
-        const mp_limb_t *limbs =
-          dump_ptr (dump_base, reload_info.data_location);
+        const mp_limb_t *limbs = dump_ptr (dump_base,
+                                           reload_info.data_location);
         mpz_roinit_n (bignum->value, limbs, reload_info.nlimbs);
         break;
       }
@@ -5790,15 +5802,29 @@ pdumper_load (const char *dump_filename, char *argv0)
     goto out;
 
   err = PDUMPER_LOAD_ERROR;
-  mark_bits_needed =
-    divide_round_up (header->discardable_start, DUMP_ALIGNMENT);
+  dump_base = (uintptr_t) sections[DS_HOT].mapping;
+
+#if !USE_LSB_TAG
+  /* The dump may have been mapped at a location that does not admit of
+     representation as Lisp_Objects.  Abort in this case.  */
+  if ((dump_base + dump_size) & ~VALMASK)
+    {
+      fprintf (stderr,
+               "Failed to load dump file: 0x%p+0x%p & 0x%p != 0\n",
+               (void *) dump_base, (void *) dump_size,
+               (void *) (uintptr_t) VALMASK);
+      goto out;
+    }
+#endif /* !USE_LSB_TAG */
+
+  mark_bits_needed
+    = divide_round_up (header->discardable_start, DUMP_ALIGNMENT);
   if (!dump_bitsets_init (mark_bits, mark_bits_needed))
     goto out;
 
   /* Point of no return.  */
   err = PDUMPER_LOAD_SUCCESS;
-  dump_base = (uintptr_t) sections[DS_HOT].mapping;
-  gflags.dumped_with_pdumper_ = true;
+  gflags.dumped_with_pdumper = true;
   dump_private.header = *header;
   dump_private.mark_bits = mark_bits[0];
   dump_private.last_mark_bits = mark_bits[1];
@@ -5815,8 +5841,8 @@ pdumper_load (const char *dump_filename, char *argv0)
   Lisp_Object hashes = zero_vector;
   if (header->hash_list)
     {
-      struct Lisp_Vector *hash_tables =
-        (struct Lisp_Vector *) (dump_base + header->hash_list);
+      struct Lisp_Vector *hash_tables
+        = (struct Lisp_Vector *) (dump_base + header->hash_list);
       hashes = make_lisp_ptr (hash_tables, Lisp_Vectorlike);
     }
 
@@ -5852,7 +5878,6 @@ pdumper_load (const char *dump_filename, char *argv0)
     dump_mmap_release (&sections[i]);
   if (dump_fd >= 0)
     emacs_close (dump_fd);
-
   return err;
 }