Merge from trunk.
[emacs.git] / src / w32heap.c
blob477c11a5160df871f083655428a0b74906542a8f
1 /* Heap management routines for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1994, 2001-2011 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 3 of the License, or
9 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
20 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
23 #include <config.h>
24 #include <stdio.h>
25 #include <setjmp.h>
27 #include "w32heap.h"
28 #include "lisp.h" /* for VALMASK */
30 #define RVA_TO_PTR(rva) ((unsigned char *)((DWORD)(rva) + (DWORD)GetModuleHandle (NULL)))
32 /* This gives us the page size and the size of the allocation unit on NT. */
33 SYSTEM_INFO sysinfo_cache;
35 /* This gives us version, build, and platform identification. */
36 OSVERSIONINFO osinfo_cache;
38 unsigned long syspage_mask = 0;
40 /* The major and minor versions of NT. */
41 int w32_major_version;
42 int w32_minor_version;
43 int w32_build_number;
45 /* Distinguish between Windows NT and Windows 95. */
46 int os_subtype;
48 /* Cache information describing the NT system for later use. */
49 void
50 cache_system_info (void)
52 union
54 struct info
56 char major;
57 char minor;
58 short platform;
59 } info;
60 DWORD data;
61 } version;
63 /* Cache the version of the operating system. */
64 version.data = GetVersion ();
65 w32_major_version = version.info.major;
66 w32_minor_version = version.info.minor;
68 if (version.info.platform & 0x8000)
69 os_subtype = OS_WIN95;
70 else
71 os_subtype = OS_NT;
73 /* Cache page size, allocation unit, processor type, etc. */
74 GetSystemInfo (&sysinfo_cache);
75 syspage_mask = sysinfo_cache.dwPageSize - 1;
77 /* Cache os info. */
78 osinfo_cache.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
79 GetVersionEx (&osinfo_cache);
81 w32_build_number = osinfo_cache.dwBuildNumber;
82 if (os_subtype == OS_WIN95)
83 w32_build_number &= 0xffff;
86 /* Emulate getpagesize. */
87 int
88 getpagesize (void)
90 return sysinfo_cache.dwPageSize;
93 /* Info for managing our preload heap, which is essentially a fixed size
94 data area in the executable. */
95 PIMAGE_SECTION_HEADER preload_heap_section;
97 /* Info for keeping track of our heap. */
98 unsigned char *data_region_base = NULL;
99 unsigned char *data_region_end = NULL;
100 unsigned char *real_data_region_end = NULL;
101 unsigned long reserved_heap_size = 0;
103 /* The start of the data segment. */
104 unsigned char *
105 get_data_start (void)
107 return data_region_base;
110 /* The end of the data segment. */
111 unsigned char *
112 get_data_end (void)
114 return data_region_end;
117 #if !defined (USE_LISP_UNION_TYPE) && !defined (USE_LSB_TAG)
118 static char *
119 allocate_heap (void)
121 /* Try to get as much as possible of the address range from the end of
122 the preload heap section up to the usable address limit. Since GNU
123 malloc can handle gaps in the memory it gets from sbrk, we can
124 simply set the sbrk pointer to the base of the new heap region. */
125 unsigned long base =
126 ROUND_UP ((RVA_TO_PTR (preload_heap_section->VirtualAddress)
127 + preload_heap_section->Misc.VirtualSize),
128 get_allocation_unit ());
129 unsigned long end = 1 << VALBITS; /* 256MB */
130 void *ptr = NULL;
132 while (!ptr && (base < end))
134 reserved_heap_size = end - base;
135 ptr = VirtualAlloc ((void *) base,
136 get_reserved_heap_size (),
137 MEM_RESERVE,
138 PAGE_NOACCESS);
139 base += 0x00100000; /* 1MB increment */
142 return ptr;
144 #else /* USE_LISP_UNION_TYPE || USE_LSB_TAG */
145 static char *
146 allocate_heap (void)
148 unsigned long size = 0x80000000; /* start by asking for 2GB */
149 void *ptr = NULL;
151 while (!ptr && size > 0x00100000)
153 reserved_heap_size = size;
154 ptr = VirtualAlloc (NULL,
155 get_reserved_heap_size (),
156 MEM_RESERVE,
157 PAGE_NOACCESS);
158 size -= 0x00800000; /* if failed, decrease request by 8MB */
161 return ptr;
163 #endif /* USE_LISP_UNION_TYPE || USE_LSB_TAG */
166 /* Emulate Unix sbrk. Note that ralloc.c expects the return value to
167 be the address of the _start_ (not end) of the new block in case of
168 success, and zero (not -1) in case of failure. */
169 void *
170 sbrk (unsigned long increment)
172 void *result;
173 long size = (long) increment;
175 result = data_region_end;
177 /* If size is negative, shrink the heap by decommitting pages. */
178 if (size < 0)
180 int new_size;
181 unsigned char *new_data_region_end;
183 size = -size;
185 /* Sanity checks. */
186 if ((data_region_end - size) < data_region_base)
187 return NULL;
189 /* We can only decommit full pages, so allow for
190 partial deallocation [cga]. */
191 new_data_region_end = (data_region_end - size);
192 new_data_region_end = (unsigned char *)
193 ((long) (new_data_region_end + syspage_mask) & ~syspage_mask);
194 new_size = real_data_region_end - new_data_region_end;
195 real_data_region_end = new_data_region_end;
196 if (new_size > 0)
198 /* Decommit size bytes from the end of the heap. */
199 if (using_dynamic_heap
200 && !VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT))
201 return NULL;
204 data_region_end -= size;
206 /* If size is positive, grow the heap by committing reserved pages. */
207 else if (size > 0)
209 /* Sanity checks. */
210 if ((data_region_end + size) >
211 (data_region_base + get_reserved_heap_size ()))
212 return NULL;
214 /* Commit more of our heap. */
215 if (using_dynamic_heap
216 && VirtualAlloc (data_region_end, size, MEM_COMMIT,
217 PAGE_READWRITE) == NULL)
218 return NULL;
219 data_region_end += size;
221 /* We really only commit full pages, so record where
222 the real end of committed memory is [cga]. */
223 real_data_region_end = (unsigned char *)
224 ((long) (data_region_end + syspage_mask) & ~syspage_mask);
227 return result;
230 /* Initialize the internal heap variables used by sbrk. When running in
231 preload phase (ie. in the undumped executable), we rely entirely on a
232 fixed size heap section included in the .exe itself; this is
233 preserved during dumping, and truncated to the size actually used.
235 When running in the dumped executable, we reserve as much as possible
236 of the address range that is addressable by Lisp object pointers, to
237 supplement what is left of the preload heap. Although we cannot rely
238 on the dynamically allocated arena being contiguous with the static
239 heap area, it is not a problem because sbrk can pretend that the gap
240 was allocated by something else; GNU malloc detects when there is a
241 jump in the sbrk values, and starts a new heap block. */
242 void
243 init_heap (void)
245 PIMAGE_DOS_HEADER dos_header;
246 PIMAGE_NT_HEADERS nt_header;
248 dos_header = (PIMAGE_DOS_HEADER) RVA_TO_PTR (0);
249 nt_header = (PIMAGE_NT_HEADERS) (((unsigned long) dos_header) +
250 dos_header->e_lfanew);
251 preload_heap_section = find_section ("EMHEAP", nt_header);
253 if (using_dynamic_heap)
255 data_region_base = allocate_heap ();
256 if (!data_region_base)
258 printf ("Error: Could not reserve dynamic heap area.\n");
259 exit (1);
262 #if !defined (USE_LISP_UNION_TYPE) && !defined (USE_LSB_TAG)
263 /* Ensure that the addresses don't use the upper tag bits since
264 the Lisp type goes there. */
265 if (((unsigned long) data_region_base & ~VALMASK) != 0)
267 printf ("Error: The heap was allocated in upper memory.\n");
268 exit (1);
270 #endif
271 data_region_end = data_region_base;
272 real_data_region_end = data_region_end;
274 else
276 data_region_base = RVA_TO_PTR (preload_heap_section->VirtualAddress);
277 data_region_end = data_region_base;
278 real_data_region_end = data_region_end;
279 reserved_heap_size = preload_heap_section->Misc.VirtualSize;
282 /* Update system version information to match current system. */
283 cache_system_info ();
286 /* Round the heap up to the given alignment. */
287 void
288 round_heap (unsigned long align)
290 unsigned long needs_to_be;
291 unsigned long need_to_alloc;
293 needs_to_be = (unsigned long) ROUND_UP (get_heap_end (), align);
294 need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
296 if (need_to_alloc)
297 sbrk (need_to_alloc);
300 #if (_MSC_VER >= 1000 && _MSC_VER < 1300 && !defined (USE_CRT_DLL))
302 /* MSVC 4.2 invokes these functions from mainCRTStartup to initialize
303 a heap via HeapCreate. They are normally defined by the runtime,
304 but we override them here so that the unnecessary HeapCreate call
305 is not performed. */
307 int __cdecl
308 _heap_init (void)
310 /* Stepping through the assembly indicates that mainCRTStartup is
311 expecting a nonzero success return value. */
312 return 1;
315 void __cdecl
316 _heap_term (void)
318 return;
321 #endif