src/w32heap.c

   1 /* Heap management routines for GNU Emacs on Windows NT.
   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 "ntheap.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 nt_major_version;
  42 int nt_minor_version;
  43
  44 /* Cache information describing the NT system for later use.  */
  45 void
  46 cache_system_info (void)
  47 {
  48   union
  49     {
  50       struct info
  51         {
  52           char  major;
  53           char  minor;
  54           short platform;
  55         } info;
  56       DWORD data;
  57     } version;
  58
  59   /* Cache the version of the operating system.  */
  60   version.data = GetVersion ();
  61   nt_major_version = version.info.major;
  62   nt_minor_version = version.info.minor;
  63
  64   /* Cache page size, allocation unit, processor type, etc.  */
  65   GetSystemInfo (&sysinfo_cache);
  66   syspage_mask = sysinfo_cache.dwPageSize - 1;
  67 }
  68
  69 /* Round ADDRESS up to be aligned with ALIGN.  */
  70 unsigned char *
  71 round_to_next (unsigned char *address, unsigned long align)
  72 {
  73   unsigned long tmp;
  74
  75   tmp = (unsigned long) address;
  76   tmp = (tmp + align - 1) / align;
  77
  78   return (unsigned char *) (tmp * align);
  79 }
  80
  81 /* Info for keeping track of our heap.  */
  82 unsigned char *data_region_base = NULL;
  83 unsigned char *data_region_end = NULL;
  84 unsigned char *real_data_region_end = NULL;
  85 unsigned long  data_region_size = 0;
  86 unsigned long  reserved_heap_size = 0;
  87
  88 /* The start of the data segment.  */
  89 unsigned char *
  90 get_data_start (void)
  91 {
  92   return data_region_base;
  93 }
  94
  95 /* The end of the data segment.  */
  96 unsigned char *
  97 get_data_end (void)
  98 {
  99   return data_region_end;
 100 }
 101
 102 static char *
 103 allocate_heap (void)
 104 {
 105   /* The base address for our GNU malloc heap is chosen in conjuction
 106      with the link settings for temacs.exe which control the stack size,
 107      the initial default process heap size and the executable image base
 108      address.  The link settings and the malloc heap base below must all
 109      correspond; the relationship between these values depends on how NT
 110      and Win95 arrange the virtual address space for a process (and on
 111      the size of the code and data segments in temacs.exe).
 112
 113      The most important thing is to make base address for the executable
 114      image high enough to leave enough room between it and the 4MB floor
 115      of the process address space on Win95 for the primary thread stack,
 116      the process default heap, and other assorted odds and ends
 117      (eg. environment strings, private system dll memory etc) that are
 118      allocated before temacs has a chance to grab its malloc arena.  The
 119      malloc heap base can then be set several MB higher than the
 120      executable image base, leaving enough room for the code and data
 121      segments.
 122
 123      Because some parts of Emacs can use rather a lot of stack space
 124      (for instance, the regular expression routines can potentially
 125      allocate several MB of stack space) we allow 8MB for the stack.
 126
 127      Allowing 1MB for the default process heap, and 1MB for odds and
 128      ends, we can base the executable at 16MB and still have a generous
 129      safety margin.  At the moment, the executable has about 810KB of
 130      code (for x86) and about 550KB of data - on RISC platforms the code
 131      size could be roughly double, so if we allow 4MB for the executable
 132      we will have plenty of room for expansion.
 133
 134      Thus we would like to set the malloc heap base to 20MB.  However,
 135      Win95 refuses to allocate the heap starting at this address, so we
 136      set the base to 27MB to make it happy.  Since Emacs now leaves
 137      28 bits available for pointers, this lets us use the remainder of
 138      the region below the 256MB line for our malloc arena - 229MB is
 139      still a pretty decent arena to play in!  */
 140
 141   unsigned long base = 0x01B00000;   /*  27MB */
 142   unsigned long end  = 1 << VALBITS; /* 256MB */
 143   void *ptr = NULL;
 144
 145 #if NTHEAP_PROBE_BASE /* This is never normally defined */
 146   /* Try various addresses looking for one the kernel will let us have.  */
 147   while (!ptr && (base < end))
 148     {
 149       reserved_heap_size = end - base;
 150       ptr = VirtualAlloc ((void *) base,
 151                           get_reserved_heap_size (),
 152                           MEM_RESERVE,
 153                           PAGE_NOACCESS);
 154       base += 0x00100000;  /* 1MB increment */
 155     }
 156 #else
 157   reserved_heap_size = end - base;
 158   ptr = VirtualAlloc ((void *) base,
 159                       get_reserved_heap_size (),
 160                       MEM_RESERVE,
 161                       PAGE_NOACCESS);
 162 #endif
 163
 164   return ptr;
 165 }
 166
 167
 168 /* Emulate Unix sbrk.  */
 169 void *
 170 sbrk (unsigned long increment)
 171 {
 172   void *result;
 173   long size = (long) increment;
 174
 175   /* Allocate our heap if we haven't done so already.  */
 176   if (!data_region_base)
 177     {
 178       data_region_base = allocate_heap ();
 179       if (!data_region_base)
 180         return NULL;
 181
 182       /* Ensure that the addresses don't use the upper tag bits since
 183          the Lisp type goes there.  */
 184       if (((unsigned long) data_region_base & ~VALMASK) != 0)
 185         {
 186           printf ("Error: The heap was allocated in upper memory.\n");
 187           exit (1);
 188         }
 189
 190       data_region_end = data_region_base;
 191       real_data_region_end = data_region_end;
 192       data_region_size = get_reserved_heap_size ();
 193     }
 194
 195   result = data_region_end;
 196
 197   /* If size is negative, shrink the heap by decommitting pages.  */
 198   if (size < 0)
 199     {
 200       int new_size;
 201       unsigned char *new_data_region_end;
 202
 203       size = -size;
 204
 205       /* Sanity checks.  */
 206       if ((data_region_end - size) < data_region_base)
 207         return NULL;
 208
 209       /* We can only decommit full pages, so allow for
 210          partial deallocation [cga].  */
 211       new_data_region_end = (data_region_end - size);
 212       new_data_region_end = (unsigned char *)
 213         ((long) (new_data_region_end + syspage_mask) & ~syspage_mask);
 214       new_size = real_data_region_end - new_data_region_end;
 215       real_data_region_end = new_data_region_end;
 216       if (new_size > 0)
 217         {
 218           /* Decommit size bytes from the end of the heap.  */
 219           if (!VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT))
 220             return NULL;
 221         }
 222
 223       data_region_end -= size;
 224     }
 225   /* If size is positive, grow the heap by committing reserved pages.  */
 226   else if (size > 0)
 227     {
 228       /* Sanity checks.  */
 229       if ((data_region_end + size) >
 230           (data_region_base + get_reserved_heap_size ()))
 231         return NULL;
 232
 233       /* Commit more of our heap. */
 234       if (VirtualAlloc (data_region_end, size, MEM_COMMIT,
 235                         PAGE_READWRITE) == NULL)
 236         return NULL;
 237       data_region_end += size;
 238
 239       /* We really only commit full pages, so record where
 240          the real end of committed memory is [cga].  */
 241       real_data_region_end = (unsigned char *)
 242           ((long) (data_region_end + syspage_mask) & ~syspage_mask);
 243     }
 244
 245   return result;
 246 }
 247
 248 /* Recreate the heap from the data that was dumped to the executable.
 249    EXECUTABLE_PATH tells us where to find the executable.  */
 250 void
 251 recreate_heap (char *executable_path)
 252 {
 253   unsigned char *tmp;
 254
 255   /* First reserve the upper part of our heap.  (We reserve first
 256      because there have been problems in the past where doing the
 257      mapping first has loaded DLLs into the VA space of our heap.)  */
 258   tmp = VirtualAlloc ((void *) get_heap_end (),
 259                       get_reserved_heap_size () - get_committed_heap_size (),
 260                       MEM_RESERVE,
 261                       PAGE_NOACCESS);
 262   if (!tmp)
 263     exit (1);
 264
 265   /* We read in the data for the .bss section from the executable
 266      first and map in the heap from the executable second to prevent
 267      any funny interactions between file I/O and file mapping.  */
 268   read_in_bss (executable_path);
 269   map_in_heap (executable_path);
 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_to_next (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 }