1 /* Heap management routines for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1994 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
30 #include "lisp.h" /* for VALMASK */
32 /* This gives us the page size and the size of the allocation unit on NT. */
33 SYSTEM_INFO sysinfo_cache
;
34 unsigned long syspage_mask
= 0;
36 /* These are defined to get Emacs to compile, but are not used. */
40 /* The major and minor versions of NT. */
41 int w32_major_version
;
42 int w32_minor_version
;
44 /* Distinguish between Windows NT and Windows 95. */
47 /* Cache information describing the NT system for later use. */
49 cache_system_info (void)
62 /* Cache the version of the operating system. */
63 version
.data
= GetVersion ();
64 w32_major_version
= version
.info
.major
;
65 w32_minor_version
= version
.info
.minor
;
67 if (version
.info
.platform
& 0x8000)
68 os_subtype
= OS_WIN95
;
72 /* Cache page size, allocation unit, processor type, etc. */
73 GetSystemInfo (&sysinfo_cache
);
74 syspage_mask
= sysinfo_cache
.dwPageSize
- 1;
77 /* Emulate getpagesize. */
81 return sysinfo_cache
.dwPageSize
;
84 /* Round ADDRESS up to be aligned with ALIGN. */
86 round_to_next (unsigned char *address
, unsigned long align
)
90 tmp
= (unsigned long) address
;
91 tmp
= (tmp
+ align
- 1) / align
;
93 return (unsigned char *) (tmp
* align
);
96 /* Info for keeping track of our heap. */
97 unsigned char *data_region_base
= NULL
;
98 unsigned char *data_region_end
= NULL
;
99 unsigned char *real_data_region_end
= NULL
;
100 unsigned long data_region_size
= 0;
101 unsigned long reserved_heap_size
= 0;
103 /* The start of the data segment. */
105 get_data_start (void)
107 return data_region_base
;
110 /* The end of the data segment. */
114 return data_region_end
;
120 /* The base address for our GNU malloc heap is chosen in conjuction
121 with the link settings for temacs.exe which control the stack size,
122 the initial default process heap size and the executable image base
123 address. The link settings and the malloc heap base below must all
124 correspond; the relationship between these values depends on how NT
125 and Windows 95 arrange the virtual address space for a process (and on
126 the size of the code and data segments in temacs.exe).
128 The most important thing is to make base address for the executable
129 image high enough to leave enough room between it and the 4MB floor
130 of the process address space on Windows 95 for the primary thread stack,
131 the process default heap, and other assorted odds and ends
132 (eg. environment strings, private system dll memory etc) that are
133 allocated before temacs has a chance to grab its malloc arena. The
134 malloc heap base can then be set several MB higher than the
135 executable image base, leaving enough room for the code and data
138 Because some parts of Emacs can use rather a lot of stack space
139 (for instance, the regular expression routines can potentially
140 allocate several MB of stack space) we allow 8MB for the stack.
142 Allowing 1MB for the default process heap, and 1MB for odds and
143 ends, we can base the executable at 16MB and still have a generous
144 safety margin. At the moment, the executable has about 810KB of
145 code (for x86) and about 550KB of data - on RISC platforms the code
146 size could be roughly double, so if we allow 4MB for the executable
147 we will have plenty of room for expansion.
149 Thus we would like to set the malloc heap base to 20MB. However,
150 Windows 95 refuses to allocate the heap starting at this address, so we
151 set the base to 27MB to make it happy. Since Emacs now leaves
152 28 bits available for pointers, this lets us use the remainder of
153 the region below the 256MB line for our malloc arena - 229MB is
154 still a pretty decent arena to play in! */
156 unsigned long base
= 0x01B00000; /* 27MB */
157 unsigned long end
= 1 << VALBITS
; /* 256MB */
160 #if NTHEAP_PROBE_BASE /* This is never normally defined */
161 /* Try various addresses looking for one the kernel will let us have. */
162 while (!ptr
&& (base
< end
))
164 reserved_heap_size
= end
- base
;
165 ptr
= VirtualAlloc ((void *) base
,
166 get_reserved_heap_size (),
169 base
+= 0x00100000; /* 1MB increment */
172 reserved_heap_size
= end
- base
;
173 ptr
= VirtualAlloc ((void *) base
,
174 get_reserved_heap_size (),
183 /* Emulate Unix sbrk. */
185 sbrk (unsigned long increment
)
188 long size
= (long) increment
;
190 /* Allocate our heap if we haven't done so already. */
191 if (!data_region_base
)
193 data_region_base
= allocate_heap ();
194 if (!data_region_base
)
197 /* Ensure that the addresses don't use the upper tag bits since
198 the Lisp type goes there. */
199 if (((unsigned long) data_region_base
& ~VALMASK
) != 0)
201 printf ("Error: The heap was allocated in upper memory.\n");
205 data_region_end
= data_region_base
;
206 real_data_region_end
= data_region_end
;
207 data_region_size
= get_reserved_heap_size ();
210 result
= data_region_end
;
212 /* If size is negative, shrink the heap by decommitting pages. */
216 unsigned char *new_data_region_end
;
221 if ((data_region_end
- size
) < data_region_base
)
224 /* We can only decommit full pages, so allow for
225 partial deallocation [cga]. */
226 new_data_region_end
= (data_region_end
- size
);
227 new_data_region_end
= (unsigned char *)
228 ((long) (new_data_region_end
+ syspage_mask
) & ~syspage_mask
);
229 new_size
= real_data_region_end
- new_data_region_end
;
230 real_data_region_end
= new_data_region_end
;
233 /* Decommit size bytes from the end of the heap. */
234 if (!VirtualFree (real_data_region_end
, new_size
, MEM_DECOMMIT
))
238 data_region_end
-= size
;
240 /* If size is positive, grow the heap by committing reserved pages. */
244 if ((data_region_end
+ size
) >
245 (data_region_base
+ get_reserved_heap_size ()))
248 /* Commit more of our heap. */
249 if (VirtualAlloc (data_region_end
, size
, MEM_COMMIT
,
250 PAGE_READWRITE
) == NULL
)
252 data_region_end
+= size
;
254 /* We really only commit full pages, so record where
255 the real end of committed memory is [cga]. */
256 real_data_region_end
= (unsigned char *)
257 ((long) (data_region_end
+ syspage_mask
) & ~syspage_mask
);
263 /* Recreate the heap from the data that was dumped to the executable.
264 EXECUTABLE_PATH tells us where to find the executable. */
266 recreate_heap (char *executable_path
)
270 /* First reserve the upper part of our heap. (We reserve first
271 because there have been problems in the past where doing the
272 mapping first has loaded DLLs into the VA space of our heap.) */
273 tmp
= VirtualAlloc ((void *) get_heap_end (),
274 get_reserved_heap_size () - get_committed_heap_size (),
280 /* We read in the data for the .bss section from the executable
281 first and map in the heap from the executable second to prevent
282 any funny interactions between file I/O and file mapping. */
283 read_in_bss (executable_path
);
284 map_in_heap (executable_path
);
286 /* Update system version information to match current system. */
287 cache_system_info ();
290 /* Round the heap up to the given alignment. */
292 round_heap (unsigned long align
)
294 unsigned long needs_to_be
;
295 unsigned long need_to_alloc
;
297 needs_to_be
= (unsigned long) round_to_next (get_heap_end (), align
);
298 need_to_alloc
= needs_to_be
- (unsigned long) get_heap_end ();
301 sbrk (need_to_alloc
);
304 #if (_MSC_VER >= 1000)
306 /* MSVC 4.2 invokes these functions from mainCRTStartup to initialize
307 a heap via HeapCreate. They are normally defined by the runtime,
308 but we override them here so that the unnecessary HeapCreate call
314 /* Stepping through the assembly indicates that mainCRTStartup is
315 expecting a nonzero success return value. */