src/w32heap.c

   1 /* Heap management routines for GNU Emacs on the Microsoft W32 API.
   2    Copyright (C) 1994, 2001-2012  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   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.
  10
  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.
  15
  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/>.  */
  18
  19 /*
  20    Geoff Voelker (voelker@cs.washington.edu)                         7-29-94
  21 */
  22
  23 #include <config.h>
  24 #include <stdio.h>
  25 #include <setjmp.h>
  26
  27 #include "w32heap.h"
  28 #include "lisp.h"  /* for VALMASK */
  29
  30 #define RVA_TO_PTR(rva) ((unsigned char *)((DWORD)(rva) + (DWORD)GetModuleHandle (NULL)))
  31
  32 /* This gives us the page size and the size of the allocation unit on NT.  */
  33 SYSTEM_INFO sysinfo_cache;
  34
  35 /* This gives us version, build, and platform identification.  */
  36 OSVERSIONINFO osinfo_cache;
  37
  38 unsigned long syspage_mask = 0;
  39
  40 /* The major and minor versions of NT.  */
  41 int w32_major_version;
  42 int w32_minor_version;
  43 int w32_build_number;
  44
  45 /* Distinguish between Windows NT and Windows 95.  */
  46 int os_subtype;
  47
  48 /* Cache information describing the NT system for later use.  */
  49 void
  50 cache_system_info (void)
  51 {
  52   union
  53     {
  54       struct info
  55         {
  56           char  major;
  57           char  minor;
  58           short platform;
  59         } info;
  60       DWORD data;
  61     } version;
  62
  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;
  67
  68   if (version.info.platform & 0x8000)
  69     os_subtype = OS_WIN95;
  70   else
  71     os_subtype = OS_NT;
  72
  73   /* Cache page size, allocation unit, processor type, etc.  */
  74   GetSystemInfo (&sysinfo_cache);
  75   syspage_mask = sysinfo_cache.dwPageSize - 1;
  76
  77   /* Cache os info.  */
  78   osinfo_cache.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
  79   GetVersionEx (&osinfo_cache);
  80
  81   w32_build_number = osinfo_cache.dwBuildNumber;
  82   if (os_subtype == OS_WIN95)
  83     w32_build_number &= 0xffff;
  84 }
  85
  86 /* Emulate getpagesize.  */
  87 int
  88 getpagesize (void)
  89 {
  90   return sysinfo_cache.dwPageSize;
  91 }
  92
  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;
  96
  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;
 102
 103 /* The start of the data segment.  */
 104 unsigned char *
 105 get_data_start (void)
 106 {
 107   return data_region_base;
 108 }
 109
 110 /* The end of the data segment.  */
 111 unsigned char *
 112 get_data_end (void)
 113 {
 114   return data_region_end;
 115 }
 116
 117 #if !defined (USE_LISP_UNION_TYPE) && !defined (USE_LSB_TAG)
 118 static char *
 119 allocate_heap (void)
 120 {
 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;
 131
 132   while (!ptr && (base < end))
 133     {
 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 */
 140     }
 141
 142   return ptr;
 143 }
 144 #else  /* USE_LISP_UNION_TYPE || USE_LSB_TAG */
 145 static char *
 146 allocate_heap (void)
 147 {
 148   unsigned long size = 0x80000000; /* start by asking for 2GB */
 149   void *ptr = NULL;
 150
 151   while (!ptr && size > 0x00100000)
 152     {
 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 */
 159     }
 160
 161   return ptr;
 162 }
 163 #endif /* USE_LISP_UNION_TYPE || USE_LSB_TAG */
 164
 165
 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)
 171 {
 172   void *result;
 173   long size = (long) increment;
 174
 175   result = data_region_end;
 176
 177   /* If size is negative, shrink the heap by decommitting pages.  */
 178   if (size < 0)
 179     {
 180       int new_size;
 181       unsigned char *new_data_region_end;
 182
 183       size = -size;
 184
 185       /* Sanity checks.  */
 186       if ((data_region_end - size) < data_region_base)
 187         return NULL;
 188
 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)
 197         {
 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;
 202         }
 203
 204       data_region_end -= size;
 205     }
 206   /* If size is positive, grow the heap by committing reserved pages.  */
 207   else if (size > 0)
 208     {
 209       /* Sanity checks.  */
 210       if ((data_region_end + size) >
 211           (data_region_base + get_reserved_heap_size ()))
 212         return NULL;
 213
 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;
 220
 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);
 225     }
 226
 227   return result;
 228 }
 229
 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.
 234
 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)
 244 {
 245   PIMAGE_DOS_HEADER dos_header;
 246   PIMAGE_NT_HEADERS nt_header;
 247
 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);
 252
 253   if (using_dynamic_heap)
 254     {
 255       data_region_base = allocate_heap ();
 256       if (!data_region_base)
 257         {
 258           printf ("Error: Could not reserve dynamic heap area.\n");
 259           exit (1);
 260         }
 261
 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)
 266         {
 267           printf ("Error: The heap was allocated in upper memory.\n");
 268           exit (1);
 269         }
 270 #endif
 271       data_region_end = data_region_base;
 272       real_data_region_end = data_region_end;
 273     }
 274   else
 275     {
 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;
 280     }
 281
 282   /* Update system version information to match current system.  */
 283   cache_system_info ();
 284 }
 285
 286 /* Round the heap up to the given alignment.  */
 287 void
 288 round_heap (unsigned long align)
 289 {
 290   unsigned long needs_to_be;
 291   unsigned long need_to_alloc;
 292
 293   needs_to_be = (unsigned long) ROUND_UP (get_heap_end (), align);
 294   need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
 295
 296   if (need_to_alloc)
 297     sbrk (need_to_alloc);
 298 }