* lisp/progmodes/python.el: Use lexical-binding.
[emacs.git] / src / w32heap.c
blob81206ce2834bcf280885987a47659b83681ce938
1 /* Heap management routines for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1994, 2001-2013 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>
26 #include "w32common.h"
27 #include "w32heap.h"
28 #include "lisp.h" /* for VALMASK */
30 #define RVA_TO_PTR(rva) ((unsigned char *)((DWORD_PTR)(rva) + (DWORD_PTR)GetModuleHandle (NULL)))
32 /* Emulate getpagesize. */
33 int
34 getpagesize (void)
36 return sysinfo_cache.dwPageSize;
39 /* Info for managing our preload heap, which is essentially a fixed size
40 data area in the executable. */
41 PIMAGE_SECTION_HEADER preload_heap_section;
43 /* Info for keeping track of our heap. */
44 unsigned char *data_region_base = NULL;
45 unsigned char *data_region_end = NULL;
46 unsigned char *real_data_region_end = NULL;
47 size_t reserved_heap_size = 0;
49 /* The start of the data segment. */
50 unsigned char *
51 get_data_start (void)
53 return data_region_base;
56 /* The end of the data segment. */
57 unsigned char *
58 get_data_end (void)
60 return data_region_end;
63 #if !USE_LSB_TAG
64 static char *
65 allocate_heap (void)
67 /* Try to get as much as possible of the address range from the end of
68 the preload heap section up to the usable address limit. Since GNU
69 malloc can handle gaps in the memory it gets from sbrk, we can
70 simply set the sbrk pointer to the base of the new heap region. */
71 DWORD_PTR base =
72 ROUND_UP ((RVA_TO_PTR (preload_heap_section->VirtualAddress)
73 + preload_heap_section->Misc.VirtualSize),
74 get_allocation_unit ());
75 DWORD_PTR end = ((unsigned __int64)1) << VALBITS; /* 256MB */
76 void *ptr = NULL;
78 while (!ptr && (base < end))
80 #ifdef _WIN64
81 reserved_heap_size = min(end - base, 0x4000000000i64); /* Limit to 256Gb */
82 #else
83 reserved_heap_size = end - base;
84 #endif
85 ptr = VirtualAlloc ((void *) base,
86 get_reserved_heap_size (),
87 MEM_RESERVE,
88 PAGE_NOACCESS);
89 base += 0x00100000; /* 1MB increment */
92 return ptr;
94 #else /* USE_LSB_TAG */
95 static char *
96 allocate_heap (void)
98 #ifdef _WIN64
99 size_t size = 0x4000000000i64; /* start by asking for 32GB */
100 #else
101 /* We used to start with 2GB here, but on Windows 7 that would leave
102 too little room in the address space for threads started by
103 Windows on our behalf, e.g. when we pop up the file selection
104 dialog. */
105 size_t size = 0x68000000; /* start by asking for 1.7GB */
106 #endif
107 void *ptr = NULL;
109 while (!ptr && size > 0x00100000)
111 reserved_heap_size = size;
112 ptr = VirtualAlloc (NULL,
113 get_reserved_heap_size (),
114 MEM_RESERVE,
115 PAGE_NOACCESS);
116 size -= 0x00800000; /* if failed, decrease request by 8MB */
119 return ptr;
121 #endif /* USE_LSB_TAG */
124 /* Emulate Unix sbrk. Note that ralloc.c expects the return value to
125 be the address of the _start_ (not end) of the new block in case of
126 success, and zero (not -1) in case of failure. */
127 void *
128 sbrk (ptrdiff_t increment)
130 void *result;
131 ptrdiff_t size = increment;
133 result = data_region_end;
135 /* If size is negative, shrink the heap by decommitting pages. */
136 if (size < 0)
138 ptrdiff_t new_size;
139 unsigned char *new_data_region_end;
141 size = -size;
143 /* Sanity checks. */
144 if ((data_region_end - size) < data_region_base)
145 return NULL;
147 /* We can only decommit full pages, so allow for
148 partial deallocation [cga]. */
149 new_data_region_end = (data_region_end - size);
150 new_data_region_end = (unsigned char *)
151 ((DWORD_PTR) (new_data_region_end + syspage_mask) & ~syspage_mask);
152 new_size = real_data_region_end - new_data_region_end;
153 real_data_region_end = new_data_region_end;
154 if (new_size > 0)
156 /* Decommit size bytes from the end of the heap. */
157 if (using_dynamic_heap
158 && !VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT))
159 return NULL;
162 data_region_end -= size;
164 /* If size is positive, grow the heap by committing reserved pages. */
165 else if (size > 0)
167 /* Sanity checks. */
168 if ((data_region_end + size) >
169 (data_region_base + get_reserved_heap_size ()))
170 return NULL;
172 /* Commit more of our heap. */
173 if (using_dynamic_heap
174 && VirtualAlloc (data_region_end, size, MEM_COMMIT,
175 PAGE_READWRITE) == NULL)
176 return NULL;
177 data_region_end += size;
179 /* We really only commit full pages, so record where
180 the real end of committed memory is [cga]. */
181 real_data_region_end = (unsigned char *)
182 ((DWORD_PTR) (data_region_end + syspage_mask) & ~syspage_mask);
185 return result;
188 /* Initialize the internal heap variables used by sbrk. When running in
189 preload phase (ie. in the undumped executable), we rely entirely on a
190 fixed size heap section included in the .exe itself; this is
191 preserved during dumping, and truncated to the size actually used.
193 When running in the dumped executable, we reserve as much as possible
194 of the address range that is addressable by Lisp object pointers, to
195 supplement what is left of the preload heap. Although we cannot rely
196 on the dynamically allocated arena being contiguous with the static
197 heap area, it is not a problem because sbrk can pretend that the gap
198 was allocated by something else; GNU malloc detects when there is a
199 jump in the sbrk values, and starts a new heap block. */
200 void
201 init_heap (void)
203 PIMAGE_DOS_HEADER dos_header;
204 PIMAGE_NT_HEADERS nt_header;
206 dos_header = (PIMAGE_DOS_HEADER) RVA_TO_PTR (0);
207 nt_header = (PIMAGE_NT_HEADERS) (((DWORD_PTR) dos_header) +
208 dos_header->e_lfanew);
209 preload_heap_section = find_section ("EMHEAP", nt_header);
211 if (using_dynamic_heap)
213 data_region_base = allocate_heap ();
214 if (!data_region_base)
216 printf ("Error: Could not reserve dynamic heap area.\n");
217 exit (1);
220 #if !USE_LSB_TAG
221 /* Ensure that the addresses don't use the upper tag bits since
222 the Lisp type goes there. */
223 if (((DWORD_PTR) data_region_base & ~VALMASK) != 0)
225 printf ("Error: The heap was allocated in upper memory.\n");
226 exit (1);
228 #endif
229 data_region_end = data_region_base;
230 real_data_region_end = data_region_end;
232 else
234 data_region_base = RVA_TO_PTR (preload_heap_section->VirtualAddress);
235 data_region_end = data_region_base;
236 real_data_region_end = data_region_end;
237 reserved_heap_size = preload_heap_section->Misc.VirtualSize;
240 /* Update system version information to match current system. */
241 cache_system_info ();
244 /* Round the heap up to the given alignment. */
245 void
246 round_heap (size_t align)
248 DWORD_PTR needs_to_be;
249 DWORD_PTR need_to_alloc;
251 needs_to_be = (DWORD_PTR) ROUND_UP (get_heap_end (), align);
252 need_to_alloc = needs_to_be - (DWORD_PTR) get_heap_end ();
254 if (need_to_alloc)
255 sbrk (need_to_alloc);