[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] trunk r117168: Use mmap(2) emulation for buffer text on MS
|
From: |
Eli Zaretskii |
|
Subject: |
[Emacs-diffs] trunk r117168: Use mmap(2) emulation for buffer text on MS-Windows. |
|
Date: |
Tue, 27 May 2014 17:33:35 +0000 |
|
User-agent: |
Bazaar (2.6b2) |
------------------------------------------------------------
revno: 117168
revision-id: address@hidden
parent: address@hidden
author: Fabrice Popineau <address@hidden>
committer: Eli Zaretskii <address@hidden>
branch nick: trunk
timestamp: Tue 2014-05-27 20:31:17 +0300
message:
Use mmap(2) emulation for buffer text on MS-Windows.
src/Makefile.in (C_HEAP_SWITCH): Get the predefined heap size from
configure.
(ADDSECTION, MINGW_TEMACS_POST_LINK): Remove, no longer used.
src/lisp.h (NONPOINTER_BITS): Modify the condition to define to zero
for MinGW, since it no longer uses gmalloc.
src/buffer.c: Do not define mmap allocations functions for Windows.
Remove mmap_find which is unused. Remove mmap_set_vars which does
nothing useful.
[WINDOWSNT]: Include w32heap.h.
(init_buffer): Always allocate new memory for buffers.
src/emacs.c: Remove mmap_set_vars calls.
src/image.c (free_image): Undef free for Windows because it is
redirected to our private version.
src/unexw32.c (COPY_PROC_CHUNK): Use %p format for 64bits
compatibility.
(copy_executable_and_dump_data): Remove dumping the heap section.
(unexec): Restore using_dynamic_heap after dumping.
src/w32heap.c (dumped_data_commit, malloc_after_dump)
(malloc_before_dump, realloc_after_dump, realloc_before_dump)
(free_after_dump, free_before_dump, mmap_alloc, mmap_realloc)
(mmap_free): New functions.
src/w32heap.h: Declare dumped_data and mmap_* function prototypes.
nt/inc/ms-w32.h: Switch to the system heap allocation scheme
instead of GNU malloc and ralloc.
nt/inc/sys/mman.h: New file.
nt/INSTALL: Update for the new build requirements.
etc/NEWS: Mention build changes on MS-Windows.
configure.ac (C_HEAP_SWITCH) define for different values of
dumped heap size depending on 32/64bits arch on Windows.
Don't check for pthreads.h on MinGW32/64, it gets in the way.
Use mmap(2) for buffers and system malloc for MinGW32/64.
added:
nt/inc/sys/mman.h mman.h-20140527171208-w5h37lgvfzdhyjf8-1
modified:
ChangeLog changelog-20091113204419-o5vbwnq5f7feedwu-1538
configure.ac
configure.in-20091113204419-o5vbwnq5f7feedwu-783
etc/ChangeLog changelog-20091113204419-o5vbwnq5f7feedwu-1485
etc/NEWS news-20100311060928-aoit31wvzf25yr1z-1
nt/ChangeLog changelog-20091113204419-o5vbwnq5f7feedwu-1545
nt/INSTALL install.msys-20130416132004-cxmtwcclsy15p2r8-1
nt/inc/ms-w32.h msw32.h-20091113204419-o5vbwnq5f7feedwu-807
src/ChangeLog changelog-20091113204419-o5vbwnq5f7feedwu-1438
src/Makefile.in makefile.in-20091113204419-o5vbwnq5f7feedwu-631
src/buffer.c buffer.c-20091113204419-o5vbwnq5f7feedwu-264
src/emacs.c emacs.c-20091113204419-o5vbwnq5f7feedwu-241
src/image.c image.c-20091113204419-o5vbwnq5f7feedwu-2969
src/lisp.h lisp.h-20091113204419-o5vbwnq5f7feedwu-253
src/unexw32.c unexw32.c-20091113204419-o5vbwnq5f7feedwu-887
src/w32heap.c w32heap.c-20091113204419-o5vbwnq5f7feedwu-810
src/w32heap.h w32heap.h-20091113204419-o5vbwnq5f7feedwu-811
=== modified file 'ChangeLog'
--- a/ChangeLog 2014-05-27 05:55:18 +0000
+++ b/ChangeLog 2014-05-27 17:31:17 +0000
@@ -1,3 +1,10 @@
+2014-05-27 Fabrice Popineau <address@hidden>
+
+ * configure.ac (C_HEAP_SWITCH) define for different values of
+ dumped heap size depending on 32/64bits arch on Windows.
+ Don't check for pthreads.h on MinGW32/64, it gets in the way.
+ Use mmap(2) for buffers and system malloc for MinGW32/64.
+
2014-05-27 Paul Eggert <address@hidden>
Merge from gnulib, incorporating:
=== modified file 'configure.ac'
--- a/configure.ac 2014-05-26 02:28:09 +0000
+++ b/configure.ac 2014-05-27 17:31:17 +0000
@@ -1973,7 +1973,7 @@
system_malloc=$emacs_cv_sanitize_address
case "$opsys" in
## darwin ld insists on the use of malloc routines in the System framework.
- darwin|sol2-10) system_malloc=yes ;;
+ darwin|mingw32|sol2-10) system_malloc=yes ;;
esac
GMALLOC_OBJ=
@@ -2020,7 +2020,7 @@
## #ifdef DOUG_LEA_MALLOC; #undef REL_ALLOC; #endif
## Does the AC_FUNC_MMAP test below make this check unnecessary?
case "$opsys" in
- gnu*) REL_ALLOC=no ;;
+ mingw32|gnu*) REL_ALLOC=no ;;
esac
fi
@@ -2030,7 +2030,7 @@
use_mmap_for_buffers=no
case "$opsys" in
- cygwin|freebsd|irix6-5) use_mmap_for_buffers=yes ;;
+ cygwin|mingw32|freebsd|irix6-5) use_mmap_for_buffers=yes ;;
esac
AC_FUNC_MMAP
@@ -2046,6 +2046,7 @@
dnl Check for the POSIX thread library.
LIB_PTHREAD=
+if test "$opsys" != "mingw32"; then
AC_CHECK_HEADERS_ONCE(pthread.h)
if test "$ac_cv_header_pthread_h"; then
dnl gmalloc.c uses pthread_atfork, which is not available on older-style
@@ -2066,6 +2067,7 @@
LIBS=$OLD_LIBS
fi
AC_SUBST([LIB_PTHREAD])
+fi
dnl Check for need for bigtoc support on IBM AIX
@@ -4817,11 +4819,9 @@
gnu*) LD_SWITCH_SYSTEM_TEMACS="\$(LD_SWITCH_X_SITE_RPATH)" ;;
mingw32)
- ## MinGW64 does not prepend an underscore to symbols, so we must
- ## pass a different -entry switch to linker. FIXME: It is better
- ## to make the entry points the same by changing unexw32.c.
+ ## Is it any better under MinGW64 to relocate emacs into higher addresses?
case "$canonical" in
- x86_64-*-*) LD_SWITCH_SYSTEM_TEMACS="-Wl,-stack,0x00800000
-Wl,-heap,0x00100000 -Wl,-image-base,0x01000000 -Wl,-entry,__start
-Wl,-Map,./temacs.map" ;;
+ x86_64-*-*) LD_SWITCH_SYSTEM_TEMACS="-Wl,-stack,0x00800000
-Wl,-heap,0x00100000 -Wl,-image-base,0x400000000 -Wl,-entry,__start
-Wl,-Map,./temacs.map" ;;
*) LD_SWITCH_SYSTEM_TEMACS="-Wl,-stack,0x00800000 -Wl,-heap,0x00100000
-Wl,-image-base,0x01000000 -Wl,-entry,__start -Wl,-Map,./temacs.map" ;;
esac
;;
@@ -4845,20 +4845,20 @@
## MinGW-specific post-link processing of temacs.
TEMACS_POST_LINK=":"
ADDSECTION=
-EMACS_HEAPSIZE=
+C_HEAP_SWITCH=
if test "${opsys}" = "mingw32"; then
TEMACS_POST_LINK="\$(MINGW_TEMACS_POST_LINK)"
ADDSECTION="../nt/addsection\$(EXEEXT)"
## Preload heap size of temacs.exe in MB.
case "$canonical" in
- x86_64-*-*) EMACS_HEAPSIZE=42 ;;
- *) EMACS_HEAPSIZE=27 ;;
+ x86_64-*-*) C_HEAP_SWITCH="-DHEAPSIZE=18" ;;
+ *) C_HEAP_SWITCH="-DHEAPSIZE=10" ;;
esac
fi
AC_SUBST(ADDSECTION)
AC_SUBST(TEMACS_POST_LINK)
-AC_SUBST(EMACS_HEAPSIZE)
+AC_SUBST(C_HEAP_SWITCH)
## Common for all window systems
if test "$window_system" != "none"; then
=== modified file 'etc/ChangeLog'
--- a/etc/ChangeLog 2014-05-26 02:28:09 +0000
+++ b/etc/ChangeLog 2014-05-27 17:31:17 +0000
@@ -1,3 +1,7 @@
+2014-05-27 Fabrice Popineau <address@hidden>
+
+ * NEWS: Mention build changes on MS-Windows.
+
2014-05-26 Paul Eggert <address@hidden>
Specify coding if Latin-1 Emacs would misinterpret (Bug#17575).
=== modified file 'etc/NEWS'
--- a/etc/NEWS 2014-05-26 02:28:09 +0000
+++ b/etc/NEWS 2014-05-27 17:31:17 +0000
@@ -40,6 +40,11 @@
** The configure option `--with-pkg-config-prog' has been removed.
Use './configure PKG_CONFIG=/full/name/of/pkg-config' if you need to.
+---
+** Building Emacs for MS-Windows requires at least Windows XP
+or Windows Server 2003. The built binaries still run on all versions
+of Windows starting with Windows 9X.
+
* Startup Changes in Emacs 24.5
=== modified file 'nt/ChangeLog'
--- a/nt/ChangeLog 2014-05-17 08:11:31 +0000
+++ b/nt/ChangeLog 2014-05-27 17:31:17 +0000
@@ -1,3 +1,12 @@
+2014-05-27 Fabrice Popineau <address@hidden>
+
+ * inc/ms-w32.h: Switch to the system heap allocation scheme
+ instead of GNU malloc and ralloc.
+
+ * inc/sys/mman.h: New file.
+
+ * INSTALL: Update for the new build requirements.
+
2014-05-17 Paul Eggert <address@hidden>
Assume C99 or later (Bug#17487).
=== modified file 'nt/INSTALL'
--- a/nt/INSTALL 2014-05-16 15:49:13 +0000
+++ b/nt/INSTALL 2014-05-27 17:31:17 +0000
@@ -5,9 +5,9 @@
See the end of the file for license conditions.
The MSYS/MinGW build described here is supported on versions of
-Windows starting with Windows 2000 and newer. Windows 9X are not
-supported (but the Emacs binary produced by this build will run on
-Windows 9X as well).
+Windows starting with Windows XP and newer. Building on Windows 2000
+and Windows 9X is not supported (but the Emacs binary produced by this
+build will run on Windows 9X and newer systems).
Do not use this recipe with Cygwin. For building on Cygwin, use the
normal installation instructions, ../INSTALL.
@@ -389,9 +389,10 @@
Where should the build process find the source code?
/path/to/emacs/sources
What compiler should emacs be built with? gcc -std=gnu99
-O0 -g3
- Should Emacs use the GNU version of malloc? yes
- Should Emacs use a relocating allocator for buffers? yes
- Should Emacs use mmap(2) for buffer allocation? no
+ Should Emacs use the GNU version of malloc? no
+ (The GNU allocators don't work with this system configuration.)
+ Should Emacs use a relocating allocator for buffers? no
+ Should Emacs use mmap(2) for buffer allocation? yes
What window system should Emacs use? w32
What toolkit should Emacs use? none
Where do we find X Windows header files? NONE
@@ -401,13 +402,16 @@
Does Emacs use -ljpeg? yes
Does Emacs use -ltiff? yes
Does Emacs use a gif library? yes
- Does Emacs use -lpng? yes
- Does Emacs use -lrsvg-2? no
+ Does Emacs use a png library? yes
+ Does Emacs use -lrsvg-2? yes
Does Emacs use imagemagick? no
+ Does Emacs support sound? no
Does Emacs use -lgpm? no
Does Emacs use -ldbus? no
Does Emacs use -lgconf? no
Does Emacs use GSettings? no
+ Does Emacs use a file notification library? yes (w32)
+ Does Emacs use access control lists? yes
Does Emacs use -lselinux? no
Does Emacs use -lgnutls? yes
Does Emacs use -lxml2? yes
@@ -415,6 +419,7 @@
Does Emacs use -lm17n-flt? no
Does Emacs use -lotf? no
Does Emacs use -lxft? no
+ Does Emacs directly use zlib? yes
Does Emacs use toolkit scroll bars? yes
You are almost there, hang on.
=== modified file 'nt/inc/ms-w32.h'
--- a/nt/inc/ms-w32.h 2014-04-21 06:37:21 +0000
+++ b/nt/inc/ms-w32.h 2014-05-27 17:31:17 +0000
@@ -140,6 +140,7 @@
in its system headers, and is not really compatible with values
lower than 0x0500, so leave it alone. */
#ifndef _W64
+# undef _WIN32_WINNT
# define _WIN32_WINNT 0x0400
#endif
@@ -427,20 +428,36 @@
#define _WINSOCK_H
/* Defines size_t and alloca (). */
-#ifdef emacs
-#define malloc e_malloc
-#define free e_free
-#define realloc e_realloc
-#define calloc e_calloc
-#endif
+#include <stdlib.h>
+#include <sys/stat.h>
#ifdef _MSC_VER
#define alloca _alloca
#else
#include <malloc.h>
#endif
-#include <stdlib.h>
-#include <sys/stat.h>
+#ifdef emacs
+
+typedef void * (* malloc_fn)(size_t);
+typedef void * (* realloc_fn)(void *, size_t);
+typedef void (* free_fn)(void *);
+
+extern void *malloc_before_dump(size_t);
+extern void *realloc_before_dump(void *, size_t);
+extern void free_before_dump(void *);
+extern void *malloc_after_dump(size_t);
+extern void *realloc_after_dump(void *, size_t);
+extern void free_after_dump(void *);
+
+extern malloc_fn the_malloc_fn;
+extern realloc_fn the_realloc_fn;
+extern free_fn the_free_fn;
+
+#define malloc(size) (*the_malloc_fn)(size)
+#define free(ptr) (*the_free_fn)(ptr)
+#define realloc(ptr, size) (*the_realloc_fn)(ptr, size)
+
+#endif
/* Define for those source files that do not include enough NT system files.
*/
#ifndef NULL
=== added file 'nt/inc/sys/mman.h'
--- a/nt/inc/sys/mman.h 1970-01-01 00:00:00 +0000
+++ b/nt/inc/sys/mman.h 2014-05-27 17:31:17 +0000
@@ -0,0 +1,31 @@
+/*
+ * sys/mman.h
+ * mman-win32
+ */
+
+#ifndef _SYS_MMAN_H_
+#define _SYS_MMAN_H_
+
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* We need MAP_ANON in src/buffer.c */
+
+#define MAP_FILE 0
+#define MAP_SHARED 1
+#define MAP_PRIVATE 2
+#define MAP_TYPE 0xf
+#define MAP_FIXED 0x10
+#define MAP_ANONYMOUS 0x20
+#define MAP_ANON MAP_ANONYMOUS
+
+#define MAP_FAILED ((void *)-1)
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* _SYS_MMAN_H_ */
=== modified file 'src/ChangeLog'
--- a/src/ChangeLog 2014-05-27 06:37:29 +0000
+++ b/src/ChangeLog 2014-05-27 17:31:17 +0000
@@ -1,3 +1,35 @@
+2014-05-27 Fabrice Popineau <address@hidden>
+
+ * Makefile.in (C_HEAP_SWITCH): Get the predefined heap size from
+ configure.
+ (ADDSECTION, MINGW_TEMACS_POST_LINK): Remove, no longer used.
+
+ * lisp.h (NONPOINTER_BITS): Modify the condition to define to zero
+ for MinGW, since it no longer uses gmalloc.
+
+ * buffer.c: Do not define mmap allocations functions for Windows.
+ Remove mmap_find which is unused. Remove mmap_set_vars which does
+ nothing useful.
+ [WINDOWSNT]: Include w32heap.h.
+ (init_buffer): Always allocate new memory for buffers.
+
+ * emacs.c: Remove mmap_set_vars calls.
+
+ * image.c (free_image): Undef free for Windows because it is
+ redirected to our private version.
+
+ * unexw32.c (COPY_PROC_CHUNK): Use %p format for 64bits
+ compatibility.
+ (copy_executable_and_dump_data): Remove dumping the heap section.
+ (unexec): Restore using_dynamic_heap after dumping.
+
+ * w32heap.c (dumped_data_commit, malloc_after_dump)
+ (malloc_before_dump, realloc_after_dump, realloc_before_dump)
+ (free_after_dump, free_before_dump, mmap_alloc, mmap_realloc)
+ (mmap_free): New functions.
+
+ * w32heap.h: Declare dumped_data and mmap_* function prototypes.
+
2014-05-27 Paul Eggert <address@hidden>
* image.c (imagemagick_load_image): Use MagickRealType for local
=== modified file 'src/Makefile.in'
--- a/src/Makefile.in 2014-05-13 14:18:54 +0000
+++ b/src/Makefile.in 2014-05-27 17:31:17 +0000
@@ -86,6 +86,9 @@
## something similar. This is normally set by configure.
address@hidden@
+## Set Emacs dumped heap size for Windows NT
address@hidden@
+
## Define LD_SWITCH_X_SITE to contain any special flags your loader
## may need to deal with X Windows. For instance, if your X libraries
## aren't in a place that your loader can find on its own, you might
@@ -300,11 +303,7 @@
## Invoke ../nt/addsection for MinGW, ":" elsewhere.
TEMACS_POST_LINK = @TEMACS_POST_LINK@
-ADDSECTION = @ADDSECTION@
EMACS_HEAPSIZE = @EMACS_HEAPSIZE@
-MINGW_TEMACS_POST_LINK = \
- mv temacs$(EXEEXT) temacs.tmp; \
- ../nt/addsection temacs.tmp temacs$(EXEEXT) EMHEAP $(EMACS_HEAPSIZE)
UNEXEC_OBJ = @UNEXEC_OBJ@
@@ -326,7 +325,7 @@
##
## FIXME? MYCPPFLAGS only referenced in etc/DEBUG.
ALL_CFLAGS=-Demacs $(MYCPPFLAGS) -I. -I$(srcdir) \
- -I$(lib) -I$(srcdir)/../lib \
+ -I$(lib) -I$(srcdir)/../lib $(C_HEAP_SWITCH) \
$(C_SWITCH_MACHINE) $(C_SWITCH_SYSTEM) $(C_SWITCH_X_SITE) \
$(GNUSTEP_CFLAGS) $(CFLAGS_SOUND) $(RSVG_CFLAGS) $(IMAGEMAGICK_CFLAGS) \
$(PNG_CFLAGS) $(LIBXML2_CFLAGS) $(DBUS_CFLAGS) \
=== modified file 'src/buffer.c'
--- a/src/buffer.c 2014-05-17 07:14:59 +0000
+++ b/src/buffer.c 2014-05-27 17:31:17 +0000
@@ -41,6 +41,10 @@
#include "keymap.h"
#include "frame.h"
+#ifdef WINDOWSNT
+#include "w32heap.h" /* for mmap_* */
+#endif
+
struct buffer *current_buffer; /* The current buffer. */
/* First buffer in chain of all buffers (in reverse order of creation).
@@ -4632,7 +4636,8 @@
Allocation with mmap
***********************************************************************/
-#ifdef USE_MMAP_FOR_BUFFERS
+/* Note: WINDOWSNT implements this stuff on w32heap.c. */
+#if defined USE_MMAP_FOR_BUFFERS && !defined WINDOWSNT
#include <sys/mman.h>
@@ -4774,36 +4779,6 @@
mmap_page_size = getpagesize ();
}
-/* Return a region overlapping address range START...END, or null if
- none. END is not including, i.e. the last byte in the range
- is at END - 1. */
-
-static struct mmap_region *
-mmap_find (void *start, void *end)
-{
- struct mmap_region *r;
- char *s = start, *e = end;
-
- for (r = mmap_regions; r; r = r->next)
- {
- char *rstart = (char *) r;
- char *rend = rstart + r->nbytes_mapped;
-
- if (/* First byte of range, i.e. START, in this region? */
- (s >= rstart && s < rend)
- /* Last byte of range, i.e. END - 1, in this region? */
- || (e > rstart && e <= rend)
- /* First byte of this region in the range? */
- || (rstart >= s && rstart < e)
- /* Last byte of this region in the range? */
- || (rend > s && rend <= e))
- break;
- }
-
- return r;
-}
-
-
/* Unmap a region. P is a pointer to the start of the user-araa of
the region. */
@@ -4880,38 +4855,6 @@
}
-/* Set or reset variables holding references to mapped regions.
- If not RESTORE_P, set all variables to null. If RESTORE_P, set all
- variables to the start of the user-areas of mapped regions.
-
- This function is called from Fdump_emacs to ensure that the dumped
- Emacs doesn't contain references to memory that won't be mapped
- when Emacs starts. */
-
-void
-mmap_set_vars (bool restore_p)
-{
- struct mmap_region *r;
-
- if (restore_p)
- {
- mmap_regions = mmap_regions_1;
- mmap_fd = mmap_fd_1;
- for (r = mmap_regions; r; r = r->next)
- *r->var = MMAP_USER_AREA (r);
- }
- else
- {
- for (r = mmap_regions; r; r = r->next)
- *r->var = NULL;
- mmap_regions_1 = mmap_regions;
- mmap_regions = NULL;
- mmap_fd_1 = mmap_fd;
- mmap_fd = -1;
- }
-}
-
-
/* Allocate a block of storage large enough to hold NBYTES bytes of
data. A pointer to the data is returned in *VAR. VAR is thus the
address of some variable which will use the data area.
=== modified file 'src/emacs.c'
--- a/src/emacs.c 2014-05-17 08:11:31 +0000
+++ b/src/emacs.c 2014-05-27 17:31:17 +0000
@@ -2155,13 +2155,8 @@
malloc_state_ptr = malloc_get_state ();
#endif
-#ifdef USE_MMAP_FOR_BUFFERS
- mmap_set_vars (0);
-#endif
unexec (SSDATA (filename), !NILP (symfile) ? SSDATA (symfile) : 0);
-#ifdef USE_MMAP_FOR_BUFFERS
- mmap_set_vars (1);
-#endif
+
#ifdef DOUG_LEA_MALLOC
free (malloc_state_ptr);
#endif
=== modified file 'src/image.c'
--- a/src/image.c 2014-05-27 06:37:29 +0000
+++ b/src/image.c 2014-05-27 17:31:17 +0000
@@ -998,6 +998,11 @@
c->images[img->id] = NULL;
+ /* Windows NT redefines 'free', but in this file, we need to
+ avoid the redefinition. */
+#ifdef WINDOWSNT
+#undef free
+#endif
/* Free resources, then free IMG. */
img->type->free (f, img);
xfree (img);
@@ -6453,7 +6458,6 @@
src->mgr.next_input_byte = NULL;
}
-
/* Load image IMG for use on frame F. Patterned after example.c
from the JPEG lib. */
=== modified file 'src/lisp.h'
--- a/src/lisp.h 2014-05-26 02:28:09 +0000
+++ b/src/lisp.h 2014-05-27 17:31:17 +0000
@@ -72,7 +72,7 @@
2. We know malloc returns a multiple of 8. */
#if (defined alignas \
&& (defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ \
- || defined DARWIN_OS || defined __sun))
+ || defined DARWIN_OS || defined __sun || defined __MINGW32__))
# define NONPOINTER_BITS 0
#else
# define NONPOINTER_BITS GCTYPEBITS
=== modified file 'src/unexw32.c'
--- a/src/unexw32.c 2014-01-11 13:36:06 +0000
+++ b/src/unexw32.c 2014-05-27 17:31:17 +0000
@@ -83,8 +83,6 @@
DWORD_PTR bss_size_static = 0;
DWORD_PTR extra_bss_size_static = 0;
-PIMAGE_SECTION_HEADER heap_section;
-
/* MinGW64 doesn't add a leading underscore to external symbols,
whereas configure.ac sets up LD_SWITCH_SYSTEM_TEMACS to force the
entry point at __start, with two underscores. */
@@ -475,8 +473,6 @@
bss_section_static = 0;
extra_bss_size_static = 0;
}
-
- heap_section = rva_to_section (PTR_TO_RVA (get_heap_start ()), nt_header);
}
@@ -518,9 +514,11 @@
if (verbose)
\
{
\
printf ("%s\n", (message));
\
- printf ("\t0x%08x Address in process.\n", s);
\
- printf ("\t0x%08x Offset in output file.\n", dst -
p_outfile->file_base); \
- printf ("\t0x%08x Size in bytes.\n", count);
\
+ printf ("\t0x%p Address in process.\n", s);
\
+ printf ("\t0x%p Base output file.\n", p_outfile->file_base); \
+ printf ("\t0x%p Offset in output file.\n", dst -
p_outfile->file_base); \
+ printf ("\t0x%p Address in output file.\n", dst); \
+ printf ("\t0x%p Size in bytes.\n", count);
\
}
\
memcpy (dst, s, count);
\
dst += count;
\
@@ -629,34 +627,6 @@
dst_section->Characteristics &= ~IMAGE_SCN_CNT_UNINITIALIZED_DATA;
dst_section->Characteristics |= IMAGE_SCN_CNT_INITIALIZED_DATA;
}
- if (section == heap_section)
- {
- DWORD_PTR heap_start = (DWORD_PTR) get_heap_start ();
- DWORD_PTR heap_size = get_committed_heap_size ();
-
- /* Dump the used portion of the predump heap, adjusting the
- section's size to the appropriate size. */
- dst = dst_save
- + RVA_TO_SECTION_OFFSET (PTR_TO_RVA (heap_start), dst_section);
- COPY_PROC_CHUNK ("Dumping heap...", heap_start, heap_size,
- be_verbose);
- ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
- dst_section->PointerToRawData = PTR_TO_OFFSET (dst_save, p_outfile);
- /* Determine new size of raw data area. */
- dst = max (dst, dst_save + dst_section->SizeOfRawData);
- dst_section->SizeOfRawData = dst - dst_save;
- /* Reduce the size of the heap section to fit (must be last
- section). */
- dst_nt_header->OptionalHeader.SizeOfImage -=
- dst_section->Misc.VirtualSize
- - ROUND_UP (dst_section->SizeOfRawData,
- dst_nt_header->OptionalHeader.SectionAlignment);
- dst_section->Misc.VirtualSize =
- ROUND_UP (dst_section->SizeOfRawData,
- dst_nt_header->OptionalHeader.SectionAlignment);
- dst_section->Characteristics &= ~IMAGE_SCN_CNT_UNINITIALIZED_DATA;
- dst_section->Characteristics |= IMAGE_SCN_CNT_INITIALIZED_DATA;
- }
/* Align the section's raw data area. */
ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
@@ -767,9 +737,6 @@
printf ("Dumping from %s\n", in_filename);
printf (" to %s\n", out_filename);
- /* We need to round off our heap to NT's page size. */
- round_heap (get_page_size ());
-
/* Open the undumped executable file. */
if (!open_input_file (&in_file, in_filename))
{
@@ -784,7 +751,6 @@
/* The size of the dumped executable is the size of the original
executable plus the size of the heap and the size of the .bss section. */
size = in_file.size +
- get_committed_heap_size () +
extra_bss_size +
extra_bss_size_static;
if (!open_output_file (&out_file, out_filename, size))
@@ -799,6 +765,10 @@
copy_executable_and_dump_data (&in_file, &out_file);
+ /* Unset it because it is plain wrong to keep it after dumping.
+ Malloc can still occur! */
+ using_dynamic_heap = FALSE;
+
/* Patch up header fields; profiler is picky about this. */
{
PIMAGE_DOS_HEADER dos_header;
=== modified file 'src/w32heap.c'
--- a/src/w32heap.c 2014-01-01 07:43:34 +0000
+++ b/src/w32heap.c 2014-05-27 17:31:17 +0000
@@ -1,256 +1,611 @@
-/* Heap management routines for GNU Emacs on the Microsoft Windows API.
- Copyright (C) 1994, 2001-2014 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 <http://www.gnu.org/licenses/>. */
-
-/*
- Geoff Voelker (address@hidden) 7-29-94
-*/
+/* Heap management routines for GNU Emacs on the Microsoft Windows
+ API. Copyright (C) 1994, 2001-2014 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 <http://www.gnu.org/licenses/>. */
+
+/*
+ Geoff Voelker (address@hidden) 7-29-94
+*/
+
+/*
+ Heavily modified by Fabrice Popineau (address@hidden) 28-02-2014
+*/
+
+/*
+ Memory allocation scheme for w32/w64:
+
+ - Buffers are mmap'ed using a very simple emulation of mmap/munmap
+ - During the temacs phase:
+ * we use a private heap declared to be stored into the `dumped_data'
+ * unfortunately, this heap cannot be made growable, so the size of
+ blocks it can allocate is limited to (0x80000 - pagesize)
+ * the blocks that are larger than this are allocated from the end
+ of the `dumped_data' array; there are not so many of them.
+ We use a very simple first-fit scheme to reuse those blocks.
+ * we check that the private heap does not cross the area used
+ by the bigger chunks.
+ - During the emacs phase:
+ * we create a private heap for new memory blocks
+ * we make sure that we never free a block that has been dumped.
+ Freeing a dumped block could work in principle, but may prove
+ unreliable if we distribute binaries of emacs.exe: MS does not
+ guarantee that the heap data structures are the same across all
+ versions of their OS, even though the API is available since XP. */
#include <config.h>
#include <stdio.h>
+#include <sys/mman.h>
#include "w32common.h"
#include "w32heap.h"
#include "lisp.h" /* for VALMASK */
-#define RVA_TO_PTR(rva) ((unsigned char *)((DWORD_PTR)(rva) +
(DWORD_PTR)GetModuleHandle (NULL)))
-
-/* Emulate getpagesize. */
-int
-getpagesize (void)
-{
- return sysinfo_cache.dwPageSize;
-}
+/* We chose to leave those declarations here. They are used only in
+ this file. The RtlCreateHeap is available since XP. It is located
+ in ntdll.dll and is available with the DDK. People often
+ complained that HeapCreate doesn't offer the ability to create a
+ heap at a given place, which we need here, and which RtlCreateHeap
+ provides. We reproduce here the definitions available with the
+ DDK. */
+
+typedef PVOID (WINAPI * RtlCreateHeap_Proc) (
+ /* _In_ */ ULONG Flags,
+ /* _In_opt_ */ PVOID HeapBase,
+ /* _In_opt_ */ SIZE_T
ReserveSize,
+ /* _In_opt_ */ SIZE_T CommitSize,
+ /* _In_opt_ */ PVOID Lock,
+ /* _In_opt_ */ PVOID Parameters
+ );
+
+typedef LONG NTSTATUS;
+
+typedef NTSTATUS
+(NTAPI * PRTL_HEAP_COMMIT_ROUTINE)(
+ IN PVOID Base,
+ IN OUT PVOID *CommitAddress,
+ IN OUT PSIZE_T CommitSize
+ );
+
+typedef struct _RTL_HEAP_PARAMETERS {
+ ULONG Length;
+ SIZE_T SegmentReserve;
+ SIZE_T SegmentCommit;
+ SIZE_T DeCommitFreeBlockThreshold;
+ SIZE_T DeCommitTotalFreeThreshold;
+ SIZE_T MaximumAllocationSize;
+ SIZE_T VirtualMemoryThreshold;
+ SIZE_T InitialCommit;
+ SIZE_T InitialReserve;
+ PRTL_HEAP_COMMIT_ROUTINE CommitRoutine;
+ SIZE_T Reserved[ 2 ];
+} RTL_HEAP_PARAMETERS, *PRTL_HEAP_PARAMETERS;
+
+/* We reserve space for dumping emacs lisp byte-code inside a static
+ array. By storing it in an array, the generic mechanism in
+ unexecw32.c will be able to dump it without the need to add a
+ special segment to the executable. In order to be able to do this
+ without losing too much space, we need to create a Windows heap at
+ the specific address of the static array. The RtlCreateHeap
+ available inside the NT kernel since XP will do this. It allows to
+ create a non-growable heap at a specific address. So before
+ dumping, we create a non-growable heap at the address of the
+ dumped_data[] array. After dumping, we reuse memory allocated
+ there without being able to free it (but most of it is not meant to
+ be freed anyway), and we use a new private heap for all new
+ allocations. */
+
+unsigned char dumped_data[DUMPED_HEAP_SIZE];
/* Info for managing our preload heap, which is essentially a fixed size
- data area in the executable. */
-PIMAGE_SECTION_HEADER preload_heap_section;
-
-/* Info for keeping track of our heap. */
+ data area in the executable. */
+/* Info for keeping track of our heap. */
unsigned char *data_region_base = NULL;
unsigned char *data_region_end = NULL;
-unsigned char *real_data_region_end = NULL;
-size_t reserved_heap_size = 0;
-
-/* The start of the data segment. */
-unsigned char *
-get_data_start (void)
-{
- return data_region_base;
-}
-
-/* The end of the data segment. */
-unsigned char *
-get_data_end (void)
-{
- return data_region_end;
-}
-
-#if !USE_LSB_TAG
-static char *
-allocate_heap (void)
-{
- /* Try to get as much as possible of the address range from the end of
- the preload heap section up to the usable address limit. Since GNU
- malloc can handle gaps in the memory it gets from sbrk, we can
- simply set the sbrk pointer to the base of the new heap region. */
- DWORD_PTR base =
- ROUND_UP ((RVA_TO_PTR (preload_heap_section->VirtualAddress)
- + preload_heap_section->Misc.VirtualSize),
- get_allocation_unit ());
- DWORD_PTR end = ((unsigned __int64)1) << VALBITS; /* 256MB */
- void *ptr = NULL;
-
- while (!ptr && (base < end))
- {
-#ifdef _WIN64
- reserved_heap_size = min(end - base, 0x4000000000ull); /* Limit to 256Gb
*/
-#else
- reserved_heap_size = end - base;
-#endif
- ptr = VirtualAlloc ((void *) base,
- get_reserved_heap_size (),
- MEM_RESERVE,
- PAGE_NOACCESS);
- base += 0x00100000; /* 1MB increment */
- }
-
- return ptr;
-}
-#else /* USE_LSB_TAG */
-static char *
-allocate_heap (void)
-{
-#ifdef _WIN64
- size_t size = 0x4000000000ull; /* start by asking for 32GB */
-#else
- /* We used to start with 2GB here, but on Windows 7 that would leave
- too little room in the address space for threads started by
- Windows on our behalf, e.g. when we pop up the file selection
- dialog. */
- size_t size = 0x68000000; /* start by asking for 1.7GB */
-#endif
- void *ptr = NULL;
-
- while (!ptr && size > 0x00100000)
- {
- reserved_heap_size = size;
- ptr = VirtualAlloc (NULL,
- get_reserved_heap_size (),
- MEM_RESERVE,
- PAGE_NOACCESS);
- size -= 0x00800000; /* if failed, decrease request by 8MB */
- }
-
- return ptr;
-}
-#endif /* USE_LSB_TAG */
-
-
-/* Emulate Unix sbrk. Note that ralloc.c expects the return value to
- be the address of the _start_ (not end) of the new block in case of
- success, and zero (not -1) in case of failure. */
-void *
-sbrk (ptrdiff_t increment)
-{
- void *result;
- ptrdiff_t size = increment;
-
- result = data_region_end;
-
- /* If size is negative, shrink the heap by decommitting pages. */
- if (size < 0)
- {
- ptrdiff_t new_size;
- unsigned char *new_data_region_end;
-
- size = -size;
-
- /* Sanity checks. */
- if ((data_region_end - size) < data_region_base)
- return NULL;
-
- /* We can only decommit full pages, so allow for
- partial deallocation [cga]. */
- new_data_region_end = (data_region_end - size);
- new_data_region_end = (unsigned char *)
- ((DWORD_PTR) (new_data_region_end + syspage_mask) & ~syspage_mask);
- new_size = real_data_region_end - new_data_region_end;
- real_data_region_end = new_data_region_end;
- if (new_size > 0)
- {
- /* Decommit size bytes from the end of the heap. */
- if (using_dynamic_heap
- && !VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT))
- return NULL;
- }
-
- data_region_end -= size;
- }
- /* If size is positive, grow the heap by committing reserved pages. */
- else if (size > 0)
- {
- /* Sanity checks. */
- if ((data_region_end + size) >
- (data_region_base + get_reserved_heap_size ()))
- return NULL;
-
- /* Commit more of our heap. */
- if (using_dynamic_heap
- && VirtualAlloc (data_region_end, size, MEM_COMMIT,
- PAGE_READWRITE) == NULL)
- return NULL;
- data_region_end += size;
-
- /* We really only commit full pages, so record where
- the real end of committed memory is [cga]. */
- real_data_region_end = (unsigned char *)
- ((DWORD_PTR) (data_region_end + syspage_mask) & ~syspage_mask);
- }
-
- return result;
-}
-
-/* Initialize the internal heap variables used by sbrk. When running in
- preload phase (ie. in the undumped executable), we rely entirely on a
- fixed size heap section included in the .exe itself; this is
- preserved during dumping, and truncated to the size actually used.
-
- When running in the dumped executable, we reserve as much as possible
- of the address range that is addressable by Lisp object pointers, to
- supplement what is left of the preload heap. Although we cannot rely
- on the dynamically allocated arena being contiguous with the static
- heap area, it is not a problem because sbrk can pretend that the gap
- was allocated by something else; GNU malloc detects when there is a
- jump in the sbrk values, and starts a new heap block. */
+static DWORD_PTR committed = 0;
+
+/* The maximum block size that can be handled by a non-growable w32
+ heap is limited by the MaxBlockSize value below.
+
+ This point deserves and explanation.
+
+ The W32 heap allocator can be used for a growable
+ heap or a non-growable one.
+
+ A growable heap is not compatible with a fixed base address for the
+ heap. Only a non-growable one is. One drawback of non-growable
+ heaps is that they can hold only objects smaller than a certain
+ size (the one defined below). Most of the largest blocks are GC'ed
+ before dumping. In any case and to be safe, we implement a simple
+ first-fit allocation algorithm starting at the end of the
+ dumped_data[] array like depicted below:
+
+ ----------------------------------------------
+ | | | |
+ | Private heap |-> <-| Big chunks |
+ | | | |
+ ----------------------------------------------
+ ^ ^ ^
+ dumped_data dumped_data bc_limit
+ + committed
+
+*/
+#define HEAP_ENTRY_SHIFT 3
+#define PAGE_SIZE 0x1000
+#define MaxBlockSize (0x80000 - PAGE_SIZE)
+
+#define MAX_BLOCKS 0x40
+
+static struct
+{
+ unsigned char *address;
+ size_t size;
+ DWORD occupied;
+} blocks[MAX_BLOCKS];
+
+static DWORD blocks_number = 0;
+static unsigned char *bc_limit;
+
+/* Handle for the private heap:
+ - inside the dumped_data[] array before dump,
+ - outside of it after dump.
+*/
+HANDLE heap = NULL;
+
+/* We redirect the standard allocation functions. */
+malloc_fn the_malloc_fn;
+realloc_fn the_realloc_fn;
+free_fn the_free_fn;
+
+/* It doesn't seem to be useful to allocate from a file mapping.
+ It would be if the memory was shared.
+
http://stackoverflow.com/questions/307060/what-is-the-purpose-of-allocating-pages-in-the-pagefile-with-createfilemapping
*/
+
+/* This is the function to commit memory when the heap allocator
+ claims for new memory. Before dumping, we allocate space
+ from the fixed size dumped_data[] array.
+*/
+NTSTATUS NTAPI
+dumped_data_commit (PVOID Base, PVOID *CommitAddress, PSIZE_T CommitSize)
+{
+ /* This is used before dumping.
+
+ The private heap is stored at dumped_data[] address.
+ We commit contiguous areas of the dumped_data array
+ as requests arrive. */
+ *CommitAddress = data_region_base + committed;
+ committed += *CommitSize;
+ if (((unsigned char *)(*CommitAddress)) + *CommitSize >= bc_limit)
+ {
+ /* Check that the private heap area does not overlap the big
+ chunks area. */
+ fprintf(stderr,
+ "dumped_data_commit: memory exhausted.\nEnlarge
dumped_data[]!\n");
+ exit (-1);
+ }
+ return 0;
+}
+
+/* Heap creation. */
+
+/* Under MinGW32, we want to turn on Low Fragmentation Heap for XP.
+ MinGW32 lacks those definitions. */
+#ifndef _W64
+typedef enum _HEAP_INFORMATION_CLASS {
+ HeapCompatibilityInformation
+} HEAP_INFORMATION_CLASS;
+
+typedef WINBASEAPI BOOL (WINAPI *
HeapSetInformation_Proc)(HANDLE,HEAP_INFORMATION_CLASS,PVOID,SIZE_T);
+#endif
+
void
init_heap (void)
{
- PIMAGE_DOS_HEADER dos_header;
- PIMAGE_NT_HEADERS nt_header;
-
- dos_header = (PIMAGE_DOS_HEADER) RVA_TO_PTR (0);
- nt_header = (PIMAGE_NT_HEADERS) (((DWORD_PTR) dos_header) +
- dos_header->e_lfanew);
- preload_heap_section = find_section ("EMHEAP", nt_header);
-
if (using_dynamic_heap)
{
- data_region_base = allocate_heap ();
- if (!data_region_base)
- {
- printf ("Error: Could not reserve dynamic heap area.\n");
- exit (1);
- }
-
-#if !USE_LSB_TAG
- /* Ensure that the addresses don't use the upper tag bits since
- the Lisp type goes there. */
- if (((DWORD_PTR) data_region_base & ~VALMASK) != 0)
- {
- printf ("Error: The heap was allocated in upper memory.\n");
- exit (1);
- }
+ unsigned long enable_lfh = 2;
+
+ /* After dumping, use a new private heap. We explicitly enable
+ the low fragmentation heap here, for the sake of pre Vista
+ versions. Note: this will harnlessly fail on Vista and
+ later, whyere the low fragmentation heap is enabled by
+ default. It will also fail on pre-Vista versions when Emacs
+ is run under a debugger; set _NO_DEBUG_HEAP=1 in the
+ environment before starting GDB to get low fragmentation heap
+ on XP and older systems, for the price of losing "certain
+ heap debug options"; for the details see
+
http://msdn.microsoft.com/en-us/library/windows/desktop/aa366705%28v=vs.85%29.aspx.
*/
+ data_region_end = data_region_base;
+
+ /* Create the private heap. */
+ heap = HeapCreate(0, 0, 0);
+
+#ifndef _W64
+ /* Set the low-fragmentation heap for OS before XP and Windows
+ Server 2003. */
+ HMODULE hm_kernel32dll = LoadLibrary("kernel32.dll");
+ HeapSetInformation_Proc s_pfn_Heap_Set_Information =
(HeapSetInformation_Proc) GetProcAddress(hm_kernel32dll, "HeapSetInformation");
+ if (s_pfn_Heap_Set_Information != NULL)
+ if (s_pfn_Heap_Set_Information ((PVOID) heap,
+ HeapCompatibilityInformation,
+ &enable_lfh, sizeof(enable_lfh)) == 0)
+ DebPrint (("Enabling Low Fragmentation Heap failed\n"));
#endif
- data_region_end = data_region_base;
- real_data_region_end = data_region_end;
+
+ the_malloc_fn = malloc_after_dump;
+ the_realloc_fn = realloc_after_dump;
+ the_free_fn = free_after_dump;
}
else
{
- data_region_base = RVA_TO_PTR (preload_heap_section->VirtualAddress);
- data_region_end = data_region_base;
- real_data_region_end = data_region_end;
- reserved_heap_size = preload_heap_section->Misc.VirtualSize;
+ /* Find the RtlCreateHeap function. Headers for this function
+ are provided with the w32 ddk, but the function is available
+ in ntdll.dll since XP. */
+ HMODULE hm_ntdll = LoadLibrary ("ntdll.dll");
+ RtlCreateHeap_Proc s_pfn_Rtl_Create_Heap
+ = (RtlCreateHeap_Proc) GetProcAddress (hm_ntdll, "RtlCreateHeap");
+ /* Specific parameters for the private heap. */
+ RTL_HEAP_PARAMETERS params;
+ ZeroMemory(¶ms, sizeof(params));
+ params.Length = sizeof(RTL_HEAP_PARAMETERS);
+
+ data_region_base = (unsigned char *)ROUND_UP (dumped_data, 0x1000);
+ data_region_end = bc_limit = dumped_data + DUMPED_HEAP_SIZE;
+
+ params.InitialCommit = committed = 0x1000;
+ params.InitialReserve = sizeof(dumped_data);
+ /* Use our own routine to commit memory from the dumped_data
+ array. */
+ params.CommitRoutine = &dumped_data_commit;
+
+ /* Create the private heap. */
+ heap = s_pfn_Rtl_Create_Heap (0, data_region_base, 0, 0, NULL, ¶ms);
+ the_malloc_fn = malloc_before_dump;
+ the_realloc_fn = realloc_before_dump;
+ the_free_fn = free_before_dump;
}
/* Update system version information to match current system. */
cache_system_info ();
}
-/* Round the heap up to the given alignment. */
-void
-round_heap (size_t align)
-{
- DWORD_PTR needs_to_be;
- DWORD_PTR need_to_alloc;
-
- needs_to_be = (DWORD_PTR) ROUND_UP (get_heap_end (), align);
- need_to_alloc = needs_to_be - (DWORD_PTR) get_heap_end ();
-
- if (need_to_alloc)
- sbrk (need_to_alloc);
+#undef malloc
+#undef realloc
+#undef calloc
+#undef free
+
+/* FREEABLE_P checks if the block can be safely freed. */
+#define FREEABLE_P(addr) \
+ ((unsigned char *)(addr) < dumped_data \
+ || (unsigned char *)(addr) >= dumped_data + DUMPED_HEAP_SIZE)
+
+void *
+malloc_after_dump (size_t size)
+{
+ /* Use the new private heap. */
+ void *p = HeapAlloc (heap, 0, size);
+
+ /* After dump, keep track of the last allocated byte for sbrk(0). */
+ data_region_end = p + size - 1;
+ return p;
+}
+
+void *
+malloc_before_dump (size_t size)
+{
+ void *p;
+
+ /* Before dumping. The private heap can handle only requests for
+ less than MaxBlockSize. */
+ if (size < MaxBlockSize)
+ {
+ /* Use the private heap if possible. */
+ p = HeapAlloc (heap, 0, size);
+ }
+ else
+ {
+ /* Find the first big chunk that can hold the requested size. */
+ int i = 0;
+
+ for (i = 0; i < blocks_number; i++)
+ {
+ if (blocks[i].occupied == 0 && blocks[i].size >= size)
+ break;
+ }
+ if (i < blocks_number)
+ {
+ /* If found, use it. */
+ p = blocks[i].address;
+ blocks[i].occupied = TRUE;
+ }
+ else
+ {
+ /* Allocate a new big chunk from the end of the dumped_data
+ array. */
+ if (blocks_number >= MAX_BLOCKS)
+ {
+ fprintf(stderr,
+ "malloc_before_dump: no more big chunks
available.\nEnlarge MAX_BLOCKS!\n");
+ exit (-1);
+ }
+ bc_limit -= size;
+ bc_limit = (unsigned char *)ROUND_DOWN (bc_limit, 0x10);
+ p = bc_limit;
+ blocks[blocks_number].address = p;
+ blocks[blocks_number].size = size;
+ blocks[blocks_number].occupied = TRUE;
+ blocks_number++;
+ if (bc_limit < dumped_data + committed)
+ {
+ /* Check that areas do not overlap. */
+ fprintf(stderr,
+ "malloc_before_dump: memory exhausted.\nEnlarge
dumped_data[]!\n");
+ exit (-1);
+ }
+ }
+ }
+ return p;
+}
+
+/* Re-allocate the previously allocated block in ptr, making the new
+ block SIZE bytes long. */
+void *
+realloc_after_dump (void *ptr, size_t size)
+{
+ void *p;
+
+ /* After dumping. */
+ if (FREEABLE_P (ptr))
+ {
+ /* Reallocate the block since it lies in the new heap. */
+ p = HeapReAlloc (heap, 0, ptr, size);
+ }
+ else
+ {
+ /* If the block lies in the dumped data, do not free it. Only
+ allocate a new one. */
+ p = HeapAlloc (heap, 0, size);
+ CopyMemory (p, ptr, size);
+ }
+ /* After dump, keep track of the last allocated byte for sbrk(0). */
+ data_region_end = p + size - 1;
+ return p;
+}
+
+void *
+realloc_before_dump (void *ptr, size_t size)
+{
+ void *p;
+
+ /* Before dumping. */
+ if (dumped_data < (unsigned char *)ptr
+ && (unsigned char *)ptr < bc_limit && size <= MaxBlockSize)
+ p = HeapReAlloc (heap, 0, ptr, size);
+ else
+ {
+ /* In this case, either the new block is too large for the heap,
+ or the old block was already too large. In both cases,
+ malloc_before_dump() and free_before_dump() will take care of
+ reallocation. */
+ p = malloc_before_dump (size);
+ CopyMemory (p, ptr, size);
+ free_before_dump (ptr);
+ }
+ return p;
+}
+
+/* Free a block allocated by `malloc', `realloc' or `calloc'. */
+void
+free_after_dump (void *ptr)
+{
+ /* After dumping. */
+ if (FREEABLE_P (ptr))
+ {
+ /* Free the block if it is in the new private heap. */
+ HeapFree (heap, 0, ptr);
+ }
+}
+
+void
+free_before_dump (void *ptr)
+{
+ /* Before dumping. */
+ if (dumped_data < (unsigned char *)ptr
+ && (unsigned char *)ptr < bc_limit)
+ {
+ /* Free the block if it is allocated in the private heap. */
+ HeapFree (heap, 0, ptr);
+ }
+ else
+ {
+ /* Look for the big chunk. */
+ int i;
+
+ for(i = 0; i < blocks_number; i++)
+ {
+ if (blocks[i].address == ptr)
+ {
+ /* Reset block occupation if found. */
+ blocks[i].occupied = 0;
+ break;
+ }
+ /* What if the block is not found? We should trigger an
+ error here. */
+ eassert (i < blocks_number);
+ }
+ }
+}
+
+/* Emulate getpagesize. */
+int
+getpagesize (void)
+{
+ return sysinfo_cache.dwPageSize;
+}
+
+void *
+sbrk (ptrdiff_t increment)
+{
+ /* The data_region_end address is the one of the last byte
+ allocated. The sbrk() function is not emulated at all, except
+ for a 0 value of its parameter. This is needed by the emacs lisp
+ function `memory-limit'. */
+ return data_region_end;
+}
+
+#define MAX_BUFFER_SIZE (512 * 1024 * 1024)
+
+/* MMAP allocation for buffers. */
+void *
+mmap_alloc (void **var, size_t nbytes)
+{
+ void *p = NULL;
+
+ /* We implement amortized allocation. We start by reserving twice
+ the size requested and commit only the size requested. Then
+ realloc could proceed and use the reserved pages, reallocating
+ only if needed. Buffer shrink would happen only so that we stay
+ in the 2x range. This is a big win when visiting compressed
+ files, where the final size of the buffer is not known in
+ advance, and the buffer is enlarged several times as the data is
+ decompressed on the fly. */
+ if (nbytes < MAX_BUFFER_SIZE)
+ p = VirtualAlloc (NULL, (nbytes * 2), MEM_RESERVE, PAGE_READWRITE);
+
+ /* If it fails, or if the request is above 512MB, try with the
+ requested size. */
+ if (p == NULL)
+ p = VirtualAlloc (NULL, nbytes, MEM_RESERVE, PAGE_READWRITE);
+
+ if (p != NULL)
+ {
+ /* Now, commit pages for NBYTES. */
+ *var = VirtualAlloc (p, nbytes, MEM_COMMIT, PAGE_READWRITE);
+ }
+
+ if (!p && GetLastError () != ERROR_NOT_ENOUGH_MEMORY)
+ DebPrint (("mmap_alloc: error %ld\n", GetLastError()));
+
+ return *var = p;
+}
+
+void
+mmap_free (void **var)
+{
+ if (*var)
+ {
+ if (VirtualFree (*var, 0, MEM_RELEASE) == 0)
+ DebPrint (("mmap_free: error %ld\n", GetLastError()));
+ *var = NULL;
+ }
+}
+
+void *
+mmap_realloc (void **var, size_t nbytes)
+{
+ MEMORY_BASIC_INFORMATION memInfo, m2;
+
+ if (*var == NULL)
+ return mmap_alloc (var, nbytes);
+
+ /* This case happens in init_buffer(). */
+ if (nbytes == 0)
+ {
+ mmap_free (var);
+ return mmap_alloc (var, nbytes);
+ }
+
+ if (VirtualQuery (*var, &memInfo, sizeof (memInfo)) == 0)
+ DebPrint (("mmap_realloc: VirtualQuery error = %ld\n", GetLastError()));
+
+ /* We need to enlarge the block. */
+ if (memInfo.RegionSize < nbytes)
+ {
+ if (VirtualQuery (*var + memInfo.RegionSize, &m2, sizeof(m2)) == 0)
+ DebPrint (("mmap_realloc: VirtualQuery error = %ld\n",
GetLastError()));
+ /* If there is enough room in the current reserved area, then
+ commit more pages as needed. */
+ if (m2.State == MEM_RESERVE
+ && nbytes <= memInfo.RegionSize + m2.RegionSize)
+ {
+ void *p;
+
+ p = VirtualAlloc (*var + memInfo.RegionSize,
+ nbytes - memInfo.RegionSize,
+ MEM_COMMIT, PAGE_READWRITE);
+ if (!p /* && GetLastError() != ERROR_NOT_ENOUGH_MEMORY */)
+ DebPrint (("realloc enlarge: VirtualAlloc error %ld\n",
+ GetLastError()));
+ return *var;
+ }
+ else
+ {
+ /* Else we must actually enlarge the block by allocating a
+ new one and copying previous contents from the old to the
+ new one. */
+ void *old_ptr = *var;
+
+ if (mmap_alloc (var, nbytes))
+ {
+ CopyMemory (*var, old_ptr, memInfo.RegionSize);
+ mmap_free (&old_ptr);
+ return *var;
+ }
+ else
+ {
+ /* We failed to enlarge the buffer. */
+ *var = old_ptr;
+ return NULL;
+ }
+ }
+ }
+
+ /* If we are shrinking by more than one page... */
+ if (memInfo.RegionSize > nbytes + getpagesize())
+ {
+ /* If we are shrinking a lot... */
+ if ((memInfo.RegionSize / 2) > nbytes)
+ {
+ /* Let's give some memory back to the system and release
+ some pages. */
+ void *old_ptr = *var;
+
+ if (mmap_alloc (var, nbytes))
+ {
+ CopyMemory (*var, old_ptr, nbytes);
+ mmap_free (&old_ptr);
+ return *var;
+ }
+ else
+ {
+ /* In case we fail to shrink, try to go on with the old block.
+ But that means there is a lot of memory pressure.
+ We could also decommit pages. */
+ *var = old_ptr;
+ return *var;
+ }
+ }
+
+ /* We still can decommit pages. */
+ if (VirtualFree (*var + nbytes + get_page_size(),
+ memInfo.RegionSize - nbytes - get_page_size(),
+ MEM_DECOMMIT) == 0)
+ DebPrint (("mmap_realloc: VirtualFree error %ld\n", GetLastError()));
+ return *var;
+ }
+
+ /* Not enlarging, not shrinking by more than one page. */
+ return *var;
}
=== modified file 'src/w32heap.h'
--- a/src/w32heap.h 2014-01-01 07:43:34 +0000
+++ b/src/w32heap.h 2014-05-27 17:31:17 +0000
@@ -27,15 +27,20 @@
/*
* Heap related stuff.
*/
-#define get_reserved_heap_size() reserved_heap_size
-#define get_committed_heap_size() (get_data_end () - get_data_start ())
-#define get_heap_start() get_data_start ()
-#define get_heap_end() get_data_end ()
+
+#define DUMPED_HEAP_SIZE (HEAPSIZE*1024*1024)
+
+extern unsigned char dumped_data[];
extern unsigned char *get_data_start (void);
extern unsigned char *get_data_end (void);
extern size_t reserved_heap_size;
-extern BOOL using_dynamic_heap;
+extern BOOL using_dynamic_heap;
+
+extern void *mmap_realloc (void **, size_t);
+extern void mmap_free (void **);
+extern void *mmap_alloc (void **, size_t);
+
/* Emulation of Unix sbrk(). */
extern void *sbrk (ptrdiff_t size);
@@ -43,11 +48,8 @@
/* Initialize heap structures for sbrk on startup. */
extern void init_heap (void);
-/* Round the heap to this size. */
-extern void round_heap (size_t size);
-
/* ----------------------------------------------------------------- */
-/* Useful routines for manipulating memory-mapped files. */
+/* Useful routines for manipulating memory-mapped files. */
typedef struct file_data {
char *name;
@@ -61,11 +63,11 @@
int open_output_file (file_data *p_file, char *name, unsigned long size);
void close_file_data (file_data *p_file);
-/* Return pointer to section header for named section. */
+/* Return pointer to section header for named section. */
IMAGE_SECTION_HEADER * find_section (char * name, IMAGE_NT_HEADERS *
nt_header);
/* Return pointer to section header for section containing the given
- relative virtual address. */
+ relative virtual address. */
IMAGE_SECTION_HEADER * rva_to_section (DWORD_PTR rva, IMAGE_NT_HEADERS *
nt_header);
#endif /* NTHEAP_H_ */
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] trunk r117168: Use mmap(2) emulation for buffer text on MS-Windows.,
Eli Zaretskii <=