code.delx.au - gnu-emacs/blob - src/w32heap.c

   1 /* Heap management routines for GNU Emacs on the Microsoft W32 API.
   2    Copyright (C) 1994, 2002, 2003, 2004, 2005,
   3                  2006 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, USA.
  21
  22    Geoff Voelker (voelker@cs.washington.edu)                         7-29-94
  23 */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31
  32 #include "w32heap.h"
  33 #include "lisp.h"  /* for VALMASK */
  34
  35 #define RVA_TO_PTR(rva) ((unsigned char *)((DWORD)(rva) + (DWORD)GetModuleHandle (NULL)))
  36
  37 /* This gives us the page size and the size of the allocation unit on NT.  */
  38 SYSTEM_INFO sysinfo_cache;
  39
  40 /* This gives us version, build, and platform identification.  */
  41 OSVERSIONINFO osinfo_cache;
  42
  43 unsigned long syspage_mask = 0;
  44
  45 /* These are defined to get Emacs to compile, but are not used.  */
  46 int edata;
  47 int etext;
  48
  49 /* The major and minor versions of NT.  */
  50 int w32_major_version;
  51 int w32_minor_version;
  52 int w32_build_number;
  53
  54 /* Distinguish between Windows NT and Windows 95.  */
  55 int os_subtype;
  56
  57 /* Cache information describing the NT system for later use.  */
  58 void
  59 cache_system_info (void)
  60 {
  61   union
  62     {
  63       struct info
  64         {
  65           char  major;
  66           char  minor;
  67           short platform;
  68         } info;
  69       DWORD data;
  70     } version;
  71
  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;
  76
  77   if (version.info.platform & 0x8000)
  78     os_subtype = OS_WIN95;
  79   else
  80     os_subtype = OS_NT;
  81
  82   /* Cache page size, allocation unit, processor type, etc.  */
  83   GetSystemInfo (&sysinfo_cache);
  84   syspage_mask = sysinfo_cache.dwPageSize - 1;
  85
  86   /* Cache os info.  */
  87   osinfo_cache.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
  88   GetVersionEx (&osinfo_cache);
  89
  90   w32_build_number = osinfo_cache.dwBuildNumber;
  91   if (os_subtype == OS_WIN95)
  92     w32_build_number &= 0xffff;
  93 }
  94
  95 /* Emulate getpagesize.  */
  96 int
  97 getpagesize (void)
  98 {
  99   return sysinfo_cache.dwPageSize;
 100 }
 101
 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;
 105
 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;
 111
 112 /* The start of the data segment.  */
 113 unsigned char *
 114 get_data_start (void)
 115 {
 116   return data_region_base;
 117 }
 118
 119 /* The end of the data segment.  */
 120 unsigned char *
 121 get_data_end (void)
 122 {
 123   return data_region_end;
 124 }
 125
 126 static char *
 127 allocate_heap (void)
 128 {
 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;
 139
 140   while (!ptr && (base < end))
 141     {
 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 */
 148     }
 149
 150   return ptr;
 151 }
 152
 153
 154 /* Emulate Unix sbrk.  */
 155 void *
 156 sbrk (unsigned long increment)
 157 {
 158   void *result;
 159   long size = (long) increment;
 160
 161   result = data_region_end;
 162
 163   /* If size is negative, shrink the heap by decommitting pages.  */
 164   if (size < 0)
 165     {
 166       int new_size;
 167       unsigned char *new_data_region_end;
 168
 169       size = -size;
 170
 171       /* Sanity checks.  */
 172       if ((data_region_end - size) < data_region_base)
 173         return NULL;
 174
 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)
 183         {
 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;
 188         }
 189
 190       data_region_end -= size;
 191     }
 192   /* If size is positive, grow the heap by committing reserved pages.  */
 193   else if (size > 0)
 194     {
 195       /* Sanity checks.  */
 196       if ((data_region_end + size) >
 197           (data_region_base + get_reserved_heap_size ()))
 198         return NULL;
 199
 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;
 206
 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);
 211     }
 212
 213   return result;
 214 }
 215
 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.
 220
 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 ()
 230 {
 231   PIMAGE_DOS_HEADER dos_header;
 232   PIMAGE_NT_HEADERS nt_header;
 233
 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);
 238
 239   if (using_dynamic_heap)
 240     {
 241       data_region_base = allocate_heap ();
 242       if (!data_region_base)
 243         {
 244           printf ("Error: Could not reserve dynamic heap area.\n");
 245           exit (1);
 246         }
 247
 248 #if defined (NO_UNION_TYPE) && !defined (USE_LSB_TAG)
 249       /* Ensure that the addresses don't use the upper tag bits since
 250          the Lisp type goes there.  */
 251       if (((unsigned long) data_region_base & ~VALMASK) != 0)
 252         {
 253           printf ("Error: The heap was allocated in upper memory.\n");
 254           exit (1);
 255         }
 256 #endif
 257       data_region_end = data_region_base;
 258       real_data_region_end = data_region_end;
 259     }
 260   else
 261     {
 262       data_region_base = RVA_TO_PTR (preload_heap_section->VirtualAddress);
 263       data_region_end = data_region_base;
 264       real_data_region_end = data_region_end;
 265       reserved_heap_size = preload_heap_section->Misc.VirtualSize;
 266     }
 267
 268   /* Update system version information to match current system.  */
 269   cache_system_info ();
 270 }
 271
 272 /* Round the heap up to the given alignment.  */
 273 void
 274 round_heap (unsigned long align)
 275 {
 276   unsigned long needs_to_be;
 277   unsigned long need_to_alloc;
 278
 279   needs_to_be = (unsigned long) ROUND_UP (get_heap_end (), align);
 280   need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
 281
 282   if (need_to_alloc)
 283     sbrk (need_to_alloc);
 284 }
 285
 286 #if (_MSC_VER >= 1000 && _MSC_VER < 1300 && !defined(USE_CRT_DLL))
 287
 288 /* MSVC 4.2 invokes these functions from mainCRTStartup to initialize
 289    a heap via HeapCreate.  They are normally defined by the runtime,
 290    but we override them here so that the unnecessary HeapCreate call
 291    is not performed.  */
 292
 293 int __cdecl
 294 _heap_init (void)
 295 {
 296   /* Stepping through the assembly indicates that mainCRTStartup is
 297      expecting a nonzero success return value.  */
 298   return 1;
 299 }
 300
 301 void __cdecl
 302 _heap_term (void)
 303 {
 304   return;
 305 }
 306
 307 #endif
 308
 309 /* arch-tag: 9a6a9860-040d-422d-8905-450dd535cd9c
 310    (do not change this comment) */