src/w32heap.c

   1 /* Heap management routines for GNU Emacs on the Microsoft W32 API.
   2    Copyright (C) 1994 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 2, or (at your option)
   9 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; 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.
  20
  21    Geoff Voelker (voelker@cs.washington.edu)                         7-29-94
  22 */
  23
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28
  29 #include "w32heap.h"
  30 #include "lisp.h"  /* for VALMASK */
  31
  32 /* This gives us the page size and the size of the allocation unit on NT.  */
  33 SYSTEM_INFO sysinfo_cache;
  34 unsigned long syspage_mask = 0;
  35
  36 /* These are defined to get Emacs to compile, but are not used.  */
  37 int edata;
  38 int etext;
  39
  40 /* The major and minor versions of NT.  */
  41 int w32_major_version;
  42 int w32_minor_version;
  43
  44 /* Distinguish between Windows NT and Windows 95.  */
  45 int os_subtype;
  46
  47 /* Cache information describing the NT system for later use.  */
  48 void
  49 cache_system_info (void)
  50 {
  51   union
  52     {
  53       struct info
  54         {
  55           char  major;
  56           char  minor;
  57           short platform;
  58         } info;
  59       DWORD data;
  60     } version;
  61
  62   /* Cache the version of the operating system.  */
  63   version.data = GetVersion ();
  64   w32_major_version = version.info.major;
  65   w32_minor_version = version.info.minor;
  66
  67   if (version.info.platform & 0x8000)
  68     os_subtype = OS_WIN95;
  69   else
  70     os_subtype = OS_NT;
  71
  72   /* Cache page size, allocation unit, processor type, etc.  */
  73   GetSystemInfo (&sysinfo_cache);
  74   syspage_mask = sysinfo_cache.dwPageSize - 1;
  75 }
  76
  77 /* Emulate getpagesize.  */
  78 int
  79 getpagesize (void)
  80 {
  81   return sysinfo_cache.dwPageSize;
  82 }
  83
  84 /* Round ADDRESS up to be aligned with ALIGN.  */
  85 unsigned char *
  86 round_to_next (unsigned char *address, unsigned long align)
  87 {
  88   unsigned long tmp;
  89
  90   tmp = (unsigned long) address;
  91   tmp = (tmp + align - 1) / align;
  92
  93   return (unsigned char *) (tmp * align);
  94 }
  95
  96 /* Info for keeping track of our heap.  */
  97 unsigned char *data_region_base = NULL;
  98 unsigned char *data_region_end = NULL;
  99 unsigned char *real_data_region_end = NULL;
 100 unsigned long  data_region_size = 0;
 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 static char *
 118 allocate_heap (void)
 119 {
 120   /* The base address for our GNU malloc heap is chosen in conjuction
 121      with the link settings for temacs.exe which control the stack size,
 122      the initial default process heap size and the executable image base
 123      address.  The link settings and the malloc heap base below must all
 124      correspond; the relationship between these values depends on how NT
 125      and Windows 95 arrange the virtual address space for a process (and on
 126      the size of the code and data segments in temacs.exe).
 127
 128      The most important thing is to make base address for the executable
 129      image high enough to leave enough room between it and the 4MB floor
 130      of the process address space on Windows 95 for the primary thread stack,
 131      the process default heap, and other assorted odds and ends
 132      (eg. environment strings, private system dll memory etc) that are
 133      allocated before temacs has a chance to grab its malloc arena.  The
 134      malloc heap base can then be set several MB higher than the
 135      executable image base, leaving enough room for the code and data
 136      segments.
 137
 138      Because some parts of Emacs can use rather a lot of stack space
 139      (for instance, the regular expression routines can potentially
 140      allocate several MB of stack space) we allow 8MB for the stack.
 141
 142      Allowing 1MB for the default process heap, and 1MB for odds and
 143      ends, we can base the executable at 16MB and still have a generous
 144      safety margin.  At the moment, the executable has about 810KB of
 145      code (for x86) and about 550KB of data - on RISC platforms the code
 146      size could be roughly double, so if we allow 4MB for the executable
 147      we will have plenty of room for expansion.
 148
 149      Thus we would like to set the malloc heap base to 20MB.  However,
 150      Windows 95 refuses to allocate the heap starting at this address, so we
 151      set the base to 27MB to make it happy.  Since Emacs now leaves
 152      28 bits available for pointers, this lets us use the remainder of
 153      the region below the 256MB line for our malloc arena - 229MB is
 154      still a pretty decent arena to play in!  */
 155
 156   unsigned long base = 0x01B00000;   /*  27MB */
 157   unsigned long end  = 1 << VALBITS; /* 256MB */
 158   void *ptr = NULL;
 159
 160 #define NTHEAP_PROBE_BASE 1
 161 #if NTHEAP_PROBE_BASE
 162   /* Try various addresses looking for one the kernel will let us have.  */
 163   while (!ptr && (base < end))
 164     {
 165       reserved_heap_size = end - base;
 166       ptr = VirtualAlloc ((void *) base,
 167                           get_reserved_heap_size (),
 168                           MEM_RESERVE,
 169                           PAGE_NOACCESS);
 170       base += 0x00100000;  /* 1MB increment */
 171     }
 172 #else
 173   reserved_heap_size = end - base;
 174   ptr = VirtualAlloc ((void *) base,
 175                       get_reserved_heap_size (),
 176                       MEM_RESERVE,
 177                       PAGE_NOACCESS);
 178 #endif
 179
 180   return ptr;
 181 }
 182
 183
 184 /* Emulate Unix sbrk.  */
 185 void *
 186 sbrk (unsigned long increment)
 187 {
 188   void *result;
 189   long size = (long) increment;
 190
 191   /* Allocate our heap if we haven't done so already.  */
 192   if (!data_region_base)
 193     {
 194       data_region_base = allocate_heap ();
 195       if (!data_region_base)
 196         return NULL;
 197
 198       /* Ensure that the addresses don't use the upper tag bits since
 199          the Lisp type goes there.  */
 200       if (((unsigned long) data_region_base & ~VALMASK) != 0)
 201         {
 202           printf ("Error: The heap was allocated in upper memory.\n");
 203           exit (1);
 204         }
 205
 206       data_region_end = data_region_base;
 207       real_data_region_end = data_region_end;
 208       data_region_size = get_reserved_heap_size ();
 209     }
 210
 211   result = data_region_end;
 212
 213   /* If size is negative, shrink the heap by decommitting pages.  */
 214   if (size < 0)
 215     {
 216       int new_size;
 217       unsigned char *new_data_region_end;
 218
 219       size = -size;
 220
 221       /* Sanity checks.  */
 222       if ((data_region_end - size) < data_region_base)
 223         return NULL;
 224
 225       /* We can only decommit full pages, so allow for
 226          partial deallocation [cga].  */
 227       new_data_region_end = (data_region_end - size);
 228       new_data_region_end = (unsigned char *)
 229         ((long) (new_data_region_end + syspage_mask) & ~syspage_mask);
 230       new_size = real_data_region_end - new_data_region_end;
 231       real_data_region_end = new_data_region_end;
 232       if (new_size > 0)
 233         {
 234           /* Decommit size bytes from the end of the heap.  */
 235           if (!VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT))
 236             return NULL;
 237         }
 238
 239       data_region_end -= size;
 240     }
 241   /* If size is positive, grow the heap by committing reserved pages.  */
 242   else if (size > 0)
 243     {
 244       /* Sanity checks.  */
 245       if ((data_region_end + size) >
 246           (data_region_base + get_reserved_heap_size ()))
 247         return NULL;
 248
 249       /* Commit more of our heap. */
 250       if (VirtualAlloc (data_region_end, size, MEM_COMMIT,
 251                         PAGE_READWRITE) == NULL)
 252         return NULL;
 253       data_region_end += size;
 254
 255       /* We really only commit full pages, so record where
 256          the real end of committed memory is [cga].  */
 257       real_data_region_end = (unsigned char *)
 258           ((long) (data_region_end + syspage_mask) & ~syspage_mask);
 259     }
 260
 261   return result;
 262 }
 263
 264 /* Recreate the heap from the data that was dumped to the executable.
 265    EXECUTABLE_PATH tells us where to find the executable.  */
 266 void
 267 recreate_heap (char *executable_path)
 268 {
 269   unsigned char *tmp;
 270
 271   /* First reserve the upper part of our heap.  (We reserve first
 272      because there have been problems in the past where doing the
 273      mapping first has loaded DLLs into the VA space of our heap.)  */
 274   tmp = VirtualAlloc ((void *) get_heap_end (),
 275                       get_reserved_heap_size () - get_committed_heap_size (),
 276                       MEM_RESERVE,
 277                       PAGE_NOACCESS);
 278   if (!tmp)
 279     w32_fatal_reload_error ("Reserving upper heap address space.");
 280
 281   /* We read in the data for the .bss section from the executable
 282      first and map in the heap from the executable second to prevent
 283      any funny interactions between file I/O and file mapping.  */
 284   read_in_bss (executable_path);
 285   map_in_heap (executable_path);
 286
 287   /* Update system version information to match current system.  */
 288   cache_system_info ();
 289 }
 290
 291 /* Round the heap up to the given alignment.  */
 292 void
 293 round_heap (unsigned long align)
 294 {
 295   unsigned long needs_to_be;
 296   unsigned long need_to_alloc;
 297
 298   needs_to_be = (unsigned long) round_to_next (get_heap_end (), align);
 299   need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
 300
 301   if (need_to_alloc)
 302     sbrk (need_to_alloc);
 303 }
 304
 305 #if (_MSC_VER >= 1000)
 306
 307 /* MSVC 4.2 invokes these functions from mainCRTStartup to initialize
 308    a heap via HeapCreate.  They are normally defined by the runtime,
 309    but we override them here so that the unnecessary HeapCreate call
 310    is not performed.  */
 311
 312 int __cdecl
 313 _heap_init (void)
 314 {
 315   /* Stepping through the assembly indicates that mainCRTStartup is
 316      expecting a nonzero success return value.  */
 317   return 1;
 318 }
 319
 320 void __cdecl
 321 _heap_term (void)
 322 {
 323   return;
 324 }
 325
 326 #endif