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

Re-port to 32-bit systems without alignment primitives

Browse source 
* 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.
This commit is contained in:
Po Lu 2025-03-09 23:02:21 +08:00
parent 57cef07710
commit a5f8ce9f1e
8 changed files with 193 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

77
configure.ac
View file

@ -3218,8 +3218,68 @@ AC_CACHE_CHECK(
fi])
doug_lea_malloc=$emacs_cv_var_doug_lea_malloc
AC_CHECK_ALIGNOF([int])
AC_CHECK_ALIGNOF([long])
AC_CHECK_ALIGNOF([long long])
AC_CHECK_SIZEOF([long])
AC_CACHE_CHECK([for struct alignment],
[emacs_cv_struct_alignment],
[AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM([[#include <stddef.h>
struct s { char c; } __attribute__ ((aligned (8)));
struct t { char c; struct s s; };
char verify[offsetof (struct t, s) == 8 ? 1 : -1];
]])],
[emacs_cv_struct_alignment=yes],
[emacs_cv_struct_alignment=no])])
if test "$emacs_cv_struct_alignment" = yes; then
AC_DEFINE([HAVE_STRUCT_ATTRIBUTE_ALIGNED], [1],
[Define to 1 if 'struct __attribute__ ((aligned (N)))' aligns the
structure to an N-byte boundary.])
fi
system_malloc=yes
# If it appears as if the system malloc can't be trusted to return
# adequately positioned memory, enable the GNU malloc, which more
# consistently provides allocations at low addresses, as is required for
# the pdumper to load dump files at a representable location.
AS_IF([test "$with_pdumper" = "yes" && test "$with_wide_int" != "yes"],
AC_CHECK_HEADERS([stdalign.h])
[AC_CACHE_CHECK([whether alignas is required yet unavailable],
[emacs_cv_alignas_unavailable],
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#ifdef HAVE_STDALIGN_H
#include <stdalign.h>
#endif
#include <limits.h>
]], [[
#define IDEAL_GCALIGNMENT 8
#if INTPTR_MAX <= INT_MAX && !defined WIDE_EMACS_INT
# define ALIGNOF_EMACS_INT ALIGNOF_INT
# elif INTPTR_MAX <= LONG_MAX && !defined WIDE_EMACS_INT
# define ALIGNOF_EMACS_INT ALIGNOF_LONG
# elif INTPTR_MAX <= LLONG_MAX
# define ALIGNOF_EMACS_INT ALIGNOF_LONG_LONG
# else
# error "INTPTR_MAX too large"
#endif
#if (ALIGNOF_EMACS_INT < IDEAL_GCALIGNMENT && !defined alignas \
&& !defined HAVE_STRUCT_ATTRIBUTE_ALIGNED \
&& !defined __alignas_is_defined \
&& __STDC_VERSION__ < 202311 && __cplusplus < 201103)
#error "!USE_LSB_TAG required"
#endif
]])], [emacs_cv_alignas_unavailable=no],
[emacs_cv_alignas_unavailable=yes])])
AS_IF([test "$emacs_cv_alignas_unavailable" = "yes"],
[system_malloc=no
AC_MSG_WARN([The GNU memory manager will be enabled as your system
does not guarantee that the portable dumper can allocate memory at a suitably
low address.])])])
dnl This must be before the test of $ac_cv_func_sbrk below.
AC_CHECK_FUNCS_ONCE([sbrk])
@ -5823,7 +5883,6 @@ AC_SUBST([HAVE_LIBSECCOMP])
AC_SUBST([LIBSECCOMP_LIBS])
AC_SUBST([LIBSECCOMP_CFLAGS])
AC_CHECK_SIZEOF([long])
SIZEOF_LONG="$ac_cv_sizeof_long"
AC_SUBST([SIZEOF_LONG])
@ -7186,22 +7245,6 @@ else
fi
AC_SUBST([LIBXMENU])
AC_CACHE_CHECK([for struct alignment],
[emacs_cv_struct_alignment],
[AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM([[#include <stddef.h>
struct s { char c; } __attribute__ ((aligned (8)));
struct t { char c; struct s s; };
char verify[offsetof (struct t, s) == 8 ? 1 : -1];
]])],
[emacs_cv_struct_alignment=yes],
[emacs_cv_struct_alignment=no])])
if test "$emacs_cv_struct_alignment" = yes; then
AC_DEFINE([HAVE_STRUCT_ATTRIBUTE_ALIGNED], [1],
[Define to 1 if 'struct __attribute__ ((aligned (N)))' aligns the
structure to an N-byte boundary.])
fi
AC_C_RESTRICT
AC_C_TYPEOF

3
msdos/sed2v2.inp
View file

@ -140,6 +140,9 @@ s/^#undef HAVE_DECL_STRTOIMAX *$/#define HAVE_DECL_STRTOIMAX 1/
s/^#undef HAVE_PDUMPER *$/#define HAVE_PDUMPER 1/
s/^#undef HAVE_STRTOLL *$/#define HAVE_STRTOLL 1/
s/^#undef HAVE_STRTOULL *$/#define HAVE_STRTOULL 1/
s/^#undef ALIGNOF_INT *$/s/^.*$/#define ALIGNOF_INT 4/
s/^#undef ALIGNOF_LONG *$/s/^.*$/#define ALIGNOF_LONG 4/
s/^#undef ALIGNOF_LONG_LONG *$/s/^.*$/#define ALIGNOF_LONG_LONG 4/
/^#undef HAVE_STRUCT_DIRENT_D_TYPE *$/c\
#if __DJGPP__ + (__DJGPP_MINOR__ >= 5) >= 3\
#define HAVE_STRUCT_DIRENT_D_TYPE 1/\

22
src/alloc.c
View file

@ -150,8 +150,6 @@ union emacs_align_type
{
struct frame frame;
struct Lisp_Bignum Lisp_Bignum;
struct Lisp_Bool_Vector Lisp_Bool_Vector;
struct Lisp_Char_Table Lisp_Char_Table;
struct Lisp_CondVar Lisp_CondVar;
struct Lisp_Finalizer Lisp_Finalizer;
struct Lisp_Float Lisp_Float;
@ -160,21 +158,25 @@ union emacs_align_type
struct Lisp_Misc_Ptr Lisp_Misc_Ptr;
struct Lisp_Mutex Lisp_Mutex;
struct Lisp_Overlay Lisp_Overlay;
struct Lisp_Sub_Char_Table Lisp_Sub_Char_Table;
struct Lisp_Subr Lisp_Subr;
struct Lisp_Sqlite Lisp_Sqlite;
struct Lisp_User_Ptr Lisp_User_Ptr;
struct Lisp_Vector Lisp_Vector;
struct terminal terminal;
struct thread_state thread_state;
struct window window;
/* Omit the following since they would require including process.h
etc. In practice their alignments never exceed that of the
structs already listed. */
etc, or because they are defined with flexible array members, which
are rejected by some C99 compilers when this union subsequently
appears in an `alignof' expression. In practice their alignments
never exceed that of the structs already listed. */
#if 0
struct Lisp_Bool_Vector Lisp_Bool_Vector;
struct Lisp_Char_Table Lisp_Char_Table;
struct Lisp_Sub_Char_Table Lisp_Sub_Char_Table;
struct Lisp_Module_Function Lisp_Module_Function;
struct Lisp_Process Lisp_Process;
struct Lisp_Vector Lisp_Vector;
struct save_window_data save_window_data;
struct scroll_bar scroll_bar;
struct xwidget_view xwidget_view;
@ -5167,14 +5169,20 @@ mark_memory (void const *start, void const *end)
for (pp = start; (void const *) pp < end; pp += GC_POINTER_ALIGNMENT)
{
void *p = *(void *const *) pp;
intptr_t ip;
#if !USE_LSB_TAG && !defined WIDE_EMACS_INT
ip = (intptr_t) p;
mark_maybe_pointer ((void *) (ip & VALMASK), false);
#else /* USE_LSB_TAG || WIDE_EMACS_INT */
mark_maybe_pointer (p, false);
#endif /* USE_LSB_TAG || WIDE_EMACS_INT */
/* Unmask any struct Lisp_Symbol pointer that make_lisp_symbol
previously disguised by adding the address of 'lispsym'.
On a host with 32-bit pointers and 64-bit Lisp_Objects,
a Lisp_Object might be split into registers saved into
non-adjacent words and P might be the low-order word's value. */
intptr_t ip;
ckd_add (&ip, (intptr_t) p, (intptr_t) lispsym);
mark_maybe_pointer ((void *) ip, true);
}

12
src/emacs.c
View file

@ -1311,13 +1311,11 @@ android_emacs_init (int argc, char **argv, char *dump_file)
if (!initialized && temacs)
{
#ifdef HAVE_PDUMPER
if (strcmp (temacs, "pdump") == 0 ||
strcmp (temacs, "pbootstrap") == 0)
gflags.will_dump_with_pdumper_ = true;
if (strcmp (temacs, "pbootstrap") == 0)
gflags.will_bootstrap_ = true;
gflags.will_dump_ =
will_dump_with_pdumper_p ();
if (!strcmp (temacs, "pdump") || !strcmp (temacs, "pbootstrap"))
gflags.will_dump_with_pdumper = true;
if (!strcmp (temacs, "pbootstrap"))
gflags.will_bootstrap = true;
gflags.will_dump = will_dump_with_pdumper_p ();
if (will_dump_p ())
dump_mode = temacs;
#endif

2
src/eval.c
View file

@ -2389,7 +2389,7 @@ it defines a macro. */)
{
/* Avoid landing here recursively while outputting the
backtrace from the error. */
gflags.will_dump_ = false;
gflags.will_dump = false;
error ("Attempt to autoload %s while preparing to dump",
SDATA (SYMBOL_NAME (funname)));
}

2
src/fns.c
View file

@ -3780,7 +3780,7 @@ FILENAME are suppressed. */)
{
/* Avoid landing here recursively while outputting the
backtrace from the error. */
gflags.will_dump_ = false;
gflags.will_dump = false;
error ("(require %s) while preparing to dump",
SDATA (SYMBOL_NAME (feature)));
}

34
src/lisp.h
View file

@ -89,18 +89,21 @@ DEFINE_GDB_SYMBOL_END (GCTYPEBITS)
typedef int EMACS_INT;
typedef unsigned int EMACS_UINT;
enum { EMACS_INT_WIDTH = INT_WIDTH, EMACS_UINT_WIDTH = UINT_WIDTH };
# define ALIGNOF_EMACS_INT ALIGNOF_INT
# define EMACS_INT_MAX INT_MAX
# define pI ""
# elif INTPTR_MAX <= LONG_MAX && !defined WIDE_EMACS_INT
typedef long int EMACS_INT;
typedef unsigned long EMACS_UINT;
enum { EMACS_INT_WIDTH = LONG_WIDTH, EMACS_UINT_WIDTH = ULONG_WIDTH };
# define ALIGNOF_EMACS_INT ALIGNOF_LONG
# define EMACS_INT_MAX LONG_MAX
# define pI "l"
# elif INTPTR_MAX <= LLONG_MAX
typedef long long int EMACS_INT;
typedef unsigned long long int EMACS_UINT;
enum { EMACS_INT_WIDTH = LLONG_WIDTH, EMACS_UINT_WIDTH = ULLONG_WIDTH };
# define ALIGNOF_EMACS_INT ALIGNOF_LONG_LONG
# define EMACS_INT_MAX LLONG_MAX
/* MinGW supports %lld only if __USE_MINGW_ANSI_STDIO is non-zero,
which is arranged by config.h, and (for mingw.org) if GCC is 6.0 or
@ -237,13 +240,26 @@ DEFINE_GDB_SYMBOL_END (INTTYPEBITS)
expression involving VAL_MAX. */
#define VAL_MAX (EMACS_INT_MAX >> (GCTYPEBITS - 1))
/* The alignment ideally required of objects subject to garbage
collection. (In the sense that it would be ideal for such an
alignment to be available to enable LSB tagging.) */
#define IDEAL_GCALIGNMENT 8
/* Whether the least-significant bits of an EMACS_INT contain the tag.
On hosts where pointers-as-ints do not exceed VAL_MAX / 2, USE_LSB_TAG is:
a. unnecessary, because the top bits of an EMACS_INT are unused, and
b. slower, because it typically requires extra masking.
So, USE_LSB_TAG is true only on hosts where it might be useful. */
DEFINE_GDB_SYMBOL_BEGIN (bool, USE_LSB_TAG)
#if (ALIGNOF_EMACS_INT < IDEAL_GCALIGNMENT && !defined alignas \
&& !defined WIDE_EMACS_INT \
&& !defined HAVE_STRUCT_ATTRIBUTE_ALIGNED \
&& !defined __alignas_is_defined \
&& __STDC_VERSION__ < 202311 && __cplusplus < 201103)
#define USE_LSB_TAG 0
#else /* EMACS_INT_WIDTH >= GCALIGNMENT || defined alignas ... */
#define USE_LSB_TAG (VAL_MAX / 2 < INTPTR_MAX)
#endif /* EMACS_INT_WIDTH >= GCALIGNMENT || defined alignas ... */
DEFINE_GDB_SYMBOL_END (USE_LSB_TAG)
/* Mask for the value (as opposed to the type bits) of a Lisp object. */
@ -262,7 +278,7 @@ DEFINE_GDB_SYMBOL_END (VALMASK)
USE_LSB_TAG, 1 otherwise. It must be a literal integer constant,
for older versions of GCC (through at least 4.9). */
#if USE_LSB_TAG
# define GCALIGNMENT 8
# define GCALIGNMENT IDEAL_GCALIGNMENT
# if GCALIGNMENT != 1 << GCTYPEBITS
# error "GCALIGNMENT and GCTYPEBITS are inconsistent"
# endif
@ -629,15 +645,15 @@ extern bool initialized;
extern struct gflags
{
/* True means this Emacs instance was born to dump. */
bool will_dump_ : 1;
bool will_bootstrap_ : 1;
bool will_dump;
bool will_bootstrap;
#ifdef HAVE_PDUMPER
/* Set in an Emacs process that will likely dump with pdumper; all
Emacs processes may dump with pdumper, however. */
bool will_dump_with_pdumper_ : 1;
bool will_dump_with_pdumper;
/* Set in an Emacs process that has been restored from a portable
dump. */
bool dumped_with_pdumper_ : 1;
bool dumped_with_pdumper;
#endif
} gflags;
@ -645,7 +661,7 @@ INLINE bool
will_dump_p (void)
{
#if HAVE_PDUMPER
return gflags.will_dump_;
return gflags.will_dump;
#else
return false;
#endif
@ -655,7 +671,7 @@ INLINE bool
will_bootstrap_p (void)
{
#if HAVE_PDUMPER
return gflags.will_bootstrap_;
return gflags.will_bootstrap;
#else
return false;
#endif
@ -665,7 +681,7 @@ INLINE bool
will_dump_with_pdumper_p (void)
{
#if HAVE_PDUMPER
return gflags.will_dump_with_pdumper_;
return gflags.will_dump_with_pdumper;
#else
return false;
#endif
@ -675,7 +691,7 @@ INLINE bool
dumped_with_pdumper_p (void)
{
#if HAVE_PDUMPER
return gflags.dumped_with_pdumper_;
return gflags.dumped_with_pdumper;
#else
return false;
#endif

111
src/pdumper.c
View file

@ -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,7 +1966,7 @@ dump_field_emacs_ptr (struct dump_context *ctx,
}
static void
_dump_object_start_pseudovector (struct dump_context *ctx,
dump_object_start_pseudovector (struct dump_context *ctx,
union vectorlike_header *out_hdr,
const union vectorlike_header *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,
@ -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,8 +4995,7 @@ 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;
@ -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;
}
@ -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;
}