git.chise.org Git - chise/xemacs-chise.git.1/blob - src/ntheap.c

   1 /* Heap management routines for XEmacs on Windows NT.
   2    Copyright (C) 1994 Free Software Foundation, Inc.
   3
   4 This file is part of XEmacs.
   5
   6 XEmacs is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with XEmacs; see the file COPYING.  If not, write to the Free
  18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.
  20
  21    Geoff Voelker (voelker@cs.washington.edu) 7-29-94 */
  22
  23 /* Adapted for XEmacs by David Hobley <david@spook-le0.cia.com.au> */
  24 /* Synced with FSF Emacs 19.34.6 by Marc Paquette <marcpa@cam.org> */
  25
  26 #include <config.h>
  27 #include "lisp.h"  /* for VALMASK */
  28
  29 #include <stdlib.h>
  30
  31 #include "ntheap.h"
  32
  33 /* This gives us the page size and the size of the allocation unit on NT.  */
  34 SYSTEM_INFO sysinfo_cache;
  35 unsigned long syspage_mask = 0;
  36
  37 /* These are defined to get Emacs to compile, but are not used.  */
  38 int edata;
  39 int etext;
  40
  41 /* The major and minor versions of NT.  */
  42 int nt_major_version;
  43 int nt_minor_version;
  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   nt_major_version = version.info.major;
  66   nt_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
  78 /* Round ADDRESS up to be aligned with ALIGN.  */
  79 unsigned char *
  80 round_to_next (unsigned char *address, unsigned long align)
  81 {
  82   unsigned long tmp;
  83
  84   tmp = (unsigned long) address;
  85   tmp = (tmp + align - 1) / align;
  86
  87   return (unsigned char *) (tmp * align);
  88 }
  89
  90 /* Info for keeping track of our heap.  */
  91 unsigned char *data_region_base = UNINIT_PTR;
  92 unsigned char *data_region_end = UNINIT_PTR;
  93 unsigned char *real_data_region_end = UNINIT_PTR;
  94 unsigned long  data_region_size = UNINIT_LONG;
  95 unsigned long  reserved_heap_size = UNINIT_LONG;
  96
  97 /* The start of the data segment.  */
  98 unsigned char *
  99 get_data_start (void)
 100 {
 101   return data_region_base;
 102 }
 103
 104 /* The end of the data segment.  */
 105 unsigned char *
 106 get_data_end (void)
 107 {
 108   return data_region_end;
 109 }
 110
 111 static char *
 112 allocate_heap (void)
 113 {
 114   /* The base address for our GNU malloc heap is chosen in conjunction
 115      with the link settings for temacs.exe which control the stack size,
 116      the initial default process heap size and the executable image base
 117      address.  The link settings and the malloc heap base below must all
 118      correspond; the relationship between these values depends on how NT
 119      and Win95 arrange the virtual address space for a process (and on
 120      the size of the code and data segments in temacs.exe).
 121
 122      The most important thing is to make base address for the executable
 123      image high enough to leave enough room between it and the 4MB floor
 124      of the process address space on Win95 for the primary thread stack,
 125      the process default heap, and other assorted odds and ends
 126      (eg. environment strings, private system dll memory etc) that are
 127      allocated before temacs has a chance to grab its malloc arena.  The
 128      malloc heap base can then be set several MB higher than the
 129      executable image base, leaving enough room for the code and data
 130      segments.
 131
 132      Because some parts of Emacs can use rather a lot of stack space
 133      (for instance, the regular expression routines can potentially
 134      allocate several MB of stack space) we allow 8MB for the stack.
 135
 136      Allowing 1MB for the default process heap, and 1MB for odds and
 137      ends, we can base the executable at 16MB and still have a generous
 138      safety margin.  At the moment, the executable has about 810KB of
 139      code (for x86) and about 550KB of data - on RISC platforms the code
 140      size could be roughly double, so if we allow 4MB for the executable
 141      we will have plenty of room for expansion.
 142
 143      Thus we would like to set the malloc heap base to 20MB.  However,
 144      Win95 refuses to allocate the heap starting at this address, so we
 145      set the base to 27MB to make it happy.  Since Emacs now leaves
 146      28 bits available for pointers, this lets us use the remainder of
 147      the region below the 256MB line for our malloc arena - 229MB is
 148      still a pretty decent arena to play in!  */
 149
 150   unsigned long base = 0x01B00000;   /*  27MB */
 151   unsigned long end  = 1 << VALBITS; /* 256MB */
 152   void *ptr = NULL;
 153
 154 #define NTHEAP_PROBE_BASE 1
 155 #if NTHEAP_PROBE_BASE /* This is never normally defined */
 156   /* Try various addresses looking for one the kernel will let us have.  */
 157   while (!ptr && (base < end))
 158     {
 159       reserved_heap_size = end - base;
 160       ptr = VirtualAlloc ((void *) base,
 161                           get_reserved_heap_size (),
 162                           MEM_RESERVE,
 163                           PAGE_NOACCESS);
 164       base += 0x00100000;  /* 1MB increment */
 165     }
 166 #else
 167   reserved_heap_size = end - base;
 168   ptr = VirtualAlloc ((void *) base,
 169                       get_reserved_heap_size (),
 170                       MEM_RESERVE,
 171                       PAGE_NOACCESS);
 172 #endif
 173
 174   return ptr;
 175 }
 176
 177
 178 /* Emulate Unix sbrk.  */
 179 void *
 180 sbrk (unsigned long increment)
 181 {
 182   void *result;
 183   long size = (long) increment;
 184
 185   /* Allocate our heap if we haven't done so already.  */
 186   if (data_region_base == UNINIT_PTR)
 187     {
 188       data_region_base = allocate_heap ();
 189       if (!data_region_base)
 190         return NULL;
 191
 192       data_region_end = data_region_base;
 193       real_data_region_end = data_region_end;
 194       data_region_size = get_reserved_heap_size ();
 195     }
 196
 197   result = data_region_end;
 198
 199   /* If size is negative, shrink the heap by decommitting pages.  */
 200   if (size < 0)
 201     {
 202       int new_size;
 203       unsigned char *new_data_region_end;
 204
 205       size = -size;
 206
 207       /* Sanity checks.  */
 208       if ((data_region_end - size) < data_region_base)
 209         return NULL;
 210
 211       /* We can only decommit full pages, so allow for
 212          partial deallocation [cga].  */
 213       new_data_region_end = (data_region_end - size);
 214       new_data_region_end = (unsigned char *)
 215         ((long) (new_data_region_end + syspage_mask) & ~syspage_mask);
 216       new_size = real_data_region_end - new_data_region_end;
 217       real_data_region_end = new_data_region_end;
 218       if (new_size > 0)
 219         {
 220           /* Decommit size bytes from the end of the heap.  */
 221           if (!VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT))
 222             return NULL;
 223         }
 224
 225       data_region_end -= size;
 226     }
 227   /* If size is positive, grow the heap by committing reserved pages.  */
 228   else if (size > 0)
 229     {
 230       /* Sanity checks.  */
 231       if ((data_region_end + size) >
 232           (data_region_base + get_reserved_heap_size ()))
 233         return NULL;
 234
 235       /* Commit more of our heap. */
 236       if (VirtualAlloc (data_region_end, size, MEM_COMMIT,
 237                         PAGE_READWRITE) == NULL)
 238         return NULL;
 239       data_region_end += size;
 240
 241       /* We really only commit full pages, so record where
 242          the real end of committed memory is [cga].  */
 243       real_data_region_end = (unsigned char *)
 244           ((long) (data_region_end + syspage_mask) & ~syspage_mask);
 245     }
 246
 247   return result;
 248 }
 249
 250 #if !defined (CANNOT_DUMP) && !defined(HEAP_IN_DATA)
 251
 252 /* Recreate the heap from the data that was dumped to the executable.
 253    EXECUTABLE_PATH tells us where to find the executable.  */
 254 void
 255 recreate_heap (char *executable_path)
 256 {
 257   unsigned char *tmp;
 258
 259   /* First reserve the upper part of our heap.  (We reserve first
 260      because there have been problems in the past where doing the
 261      mapping first has loaded DLLs into the VA space of our heap.)  */
 262   tmp = VirtualAlloc ((void *) get_heap_end (),
 263                       get_reserved_heap_size () - get_committed_heap_size (),
 264                       MEM_RESERVE,
 265                       PAGE_NOACCESS);
 266   if (!tmp)
 267     exit (1);
 268
 269   /* We read in the data for the .bss section from the executable
 270      first and map in the heap from the executable second to prevent
 271      any funny interactions between file I/O and file mapping.  */
 272   read_in_bss (executable_path);
 273   map_in_heap (executable_path);
 274
 275   /* Update system version information to match current system.  */
 276   cache_system_info ();
 277 }
 278 #endif /* CANNOT_DUMP */
 279
 280 /* Round the heap up to the given alignment.  */
 281 void
 282 round_heap (unsigned long align)
 283 {
 284   unsigned long needs_to_be;
 285   unsigned long need_to_alloc;
 286
 287   needs_to_be = (unsigned long) round_to_next (get_heap_end (), align);
 288   need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
 289
 290   if (need_to_alloc)
 291     sbrk (need_to_alloc);
 292 }
 293
 294 #if (_MSC_VER >= 1000)
 295
 296 /* MSVC 4.2 invokes these functions from mainCRTStartup to initialize
 297    a heap via HeapCreate.  They are normally defined by the runtime,
 298    but we override them here so that the unnecessary HeapCreate call
 299    is not performed.  */
 300
 301 int __cdecl
 302 _heap_init (void)
 303 {
 304   /* Stepping through the assembly indicates that mainCRTStartup is
 305      expecting a nonzero success return value.  */
 306   return 1;
 307 }
 308
 309 void __cdecl
 310 _heap_term (void)
 311 {
 312   return;
 313 }
 314
 315 #endif