*** empty log message ***
[emacs.git] / src / w32heap.c
blob11ec7c1b6c6b5b2eb84e9eee2d26a516ae4e063b
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)
9 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; 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
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
28 #include <stdlib.h>
29 #include <stdio.h>
31 #include "w32heap.h"
32 #include "lisp.h" /* for VALMASK */
34 #undef RVA_TO_PTR
35 #define RVA_TO_PTR(rva) ((unsigned char *)((DWORD)(rva) + (DWORD)GetModuleHandle (NULL)))
37 /* This gives us the page size and the size of the allocation unit on NT. */
38 SYSTEM_INFO sysinfo_cache;
40 /* This gives us version, build, and platform identification. */
41 OSVERSIONINFO osinfo_cache;
43 unsigned long syspage_mask = 0;
45 /* These are defined to get Emacs to compile, but are not used. */
46 int edata;
47 int etext;
49 /* The major and minor versions of NT. */
50 int w32_major_version;
51 int w32_minor_version;
52 int w32_build_number;
54 /* Distinguish between Windows NT and Windows 95. */
55 int os_subtype;
57 /* Cache information describing the NT system for later use. */
58 void
59 cache_system_info (void)
61 union
63 struct info
65 char major;
66 char minor;
67 short platform;
68 } info;
69 DWORD data;
70 } version;
72 /* Cache the version of the operating system. */
73 version.data = GetVersion ();
74 w32_major_version = version.info.major;
75 w32_minor_version = version.info.minor;
77 if (version.info.platform & 0x8000)
78 os_subtype = OS_WIN95;
79 else
80 os_subtype = OS_NT;
82 /* Cache page size, allocation unit, processor type, etc. */
83 GetSystemInfo (&sysinfo_cache);
84 syspage_mask = sysinfo_cache.dwPageSize - 1;
86 /* Cache os info. */
87 osinfo_cache.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
88 GetVersionEx (&osinfo_cache);
90 w32_build_number = osinfo_cache.dwBuildNumber;
91 if (os_subtype == OS_WIN95)
92 w32_build_number &= 0xffff;
95 /* Emulate getpagesize. */
96 int
97 getpagesize (void)
99 return sysinfo_cache.dwPageSize;
102 /* Info for managing our preload heap, which is essentially a fixed size
103 data area in the executable. */
104 PIMAGE_SECTION_HEADER preload_heap_section;
106 /* Info for keeping track of our heap. */
107 unsigned char *data_region_base = NULL;
108 unsigned char *data_region_end = NULL;
109 unsigned char *real_data_region_end = NULL;
110 unsigned long reserved_heap_size = 0;
112 /* The start of the data segment. */
113 unsigned char *
114 get_data_start (void)
116 return data_region_base;
119 /* The end of the data segment. */
120 unsigned char *
121 get_data_end (void)
123 return data_region_end;
126 static char *
127 allocate_heap (void)
129 /* Try to get as much as possible of the address range from the end of
130 the preload heap section up to the usable address limit. Since GNU
131 malloc can handle gaps in the memory it gets from sbrk, we can
132 simply set the sbrk pointer to the base of the new heap region. */
133 unsigned long base =
134 ROUND_UP ((RVA_TO_PTR (preload_heap_section->VirtualAddress)
135 + preload_heap_section->Misc.VirtualSize),
136 get_allocation_unit ());
137 unsigned long end = 1 << VALBITS; /* 256MB */
138 void *ptr = NULL;
140 while (!ptr && (base < end))
142 reserved_heap_size = end - base;
143 ptr = VirtualAlloc ((void *) base,
144 get_reserved_heap_size (),
145 MEM_RESERVE,
146 PAGE_NOACCESS);
147 base += 0x00100000; /* 1MB increment */
150 return ptr;
154 /* Emulate Unix sbrk. */
155 void *
156 sbrk (unsigned long increment)
158 void *result;
159 long size = (long) increment;
161 result = data_region_end;
163 /* If size is negative, shrink the heap by decommitting pages. */
164 if (size < 0)
166 int new_size;
167 unsigned char *new_data_region_end;
169 size = -size;
171 /* Sanity checks. */
172 if ((data_region_end - size) < data_region_base)
173 return NULL;
175 /* We can only decommit full pages, so allow for
176 partial deallocation [cga]. */
177 new_data_region_end = (data_region_end - size);
178 new_data_region_end = (unsigned char *)
179 ((long) (new_data_region_end + syspage_mask) & ~syspage_mask);
180 new_size = real_data_region_end - new_data_region_end;
181 real_data_region_end = new_data_region_end;
182 if (new_size > 0)
184 /* Decommit size bytes from the end of the heap. */
185 if (using_dynamic_heap
186 && !VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT))
187 return NULL;
190 data_region_end -= size;
192 /* If size is positive, grow the heap by committing reserved pages. */
193 else if (size > 0)
195 /* Sanity checks. */
196 if ((data_region_end + size) >
197 (data_region_base + get_reserved_heap_size ()))
198 return NULL;
200 /* Commit more of our heap. */
201 if (using_dynamic_heap
202 && VirtualAlloc (data_region_end, size, MEM_COMMIT,
203 PAGE_READWRITE) == NULL)
204 return NULL;
205 data_region_end += size;
207 /* We really only commit full pages, so record where
208 the real end of committed memory is [cga]. */
209 real_data_region_end = (unsigned char *)
210 ((long) (data_region_end + syspage_mask) & ~syspage_mask);
213 return result;
216 /* Initialize the internal heap variables used by sbrk. When running in
217 preload phase (ie. in the undumped executable), we rely entirely on a
218 fixed size heap section included in the .exe itself; this is
219 preserved during dumping, and truncated to the size actually used.
221 When running in the dumped executable, we reserve as much as possible
222 of the address range that is addressable by Lisp object pointers, to
223 supplement what is left of the preload heap. Although we cannot rely
224 on the dynamically allocated arena being contiguous with the static
225 heap area, it is not a problem because sbrk can pretend that the gap
226 was allocated by something else; GNU malloc detects when there is a
227 jump in the sbrk values, and starts a new heap block. */
228 void
229 init_heap ()
231 PIMAGE_DOS_HEADER dos_header;
232 PIMAGE_NT_HEADERS nt_header;
234 dos_header = (PIMAGE_DOS_HEADER) RVA_TO_PTR (0);
235 nt_header = (PIMAGE_NT_HEADERS) (((unsigned long) dos_header) +
236 dos_header->e_lfanew);
237 preload_heap_section = find_section ("EMHEAP", nt_header);
239 if (using_dynamic_heap)
241 data_region_base = allocate_heap ();
242 if (!data_region_base)
244 printf ("Error: Could not reserve dynamic heap area.\n");
245 exit (1);
248 /* Ensure that the addresses don't use the upper tag bits since
249 the Lisp type goes there. */
250 if (((unsigned long) data_region_base & ~VALMASK) != 0)
252 printf ("Error: The heap was allocated in upper memory.\n");
253 exit (1);
256 data_region_end = data_region_base;
257 real_data_region_end = data_region_end;
259 else
261 data_region_base = RVA_TO_PTR (preload_heap_section->VirtualAddress);
262 data_region_end = data_region_base;
263 real_data_region_end = data_region_end;
264 reserved_heap_size = preload_heap_section->Misc.VirtualSize;
267 /* Update system version information to match current system. */
268 cache_system_info ();
271 /* Round the heap up to the given alignment. */
272 void
273 round_heap (unsigned long align)
275 unsigned long needs_to_be;
276 unsigned long need_to_alloc;
278 needs_to_be = (unsigned long) ROUND_UP (get_heap_end (), align);
279 need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
281 if (need_to_alloc)
282 sbrk (need_to_alloc);
285 #if (_MSC_VER >= 1000 && _MSC_VER < 1300 && !defined(USE_CRT_DLL))
287 /* MSVC 4.2 invokes these functions from mainCRTStartup to initialize
288 a heap via HeapCreate. They are normally defined by the runtime,
289 but we override them here so that the unnecessary HeapCreate call
290 is not performed. */
292 int __cdecl
293 _heap_init (void)
295 /* Stepping through the assembly indicates that mainCRTStartup is
296 expecting a nonzero success return value. */
297 return 1;
300 void __cdecl
301 _heap_term (void)
303 return;
306 #endif