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 #ifndef USE_MINIMAL_TAGBITS
 193       /* Ensure that the addresses don't use the upper tag bits since
 194          the Lisp type goes there.  */
 195 #ifdef USE_UNION_TYPE
 196       if (((unsigned long) data_region_base & ~((1U << VALBITS) - 1)) != 0)
 197 #else
 198       if (((unsigned long) data_region_base & ~VALMASK) != 0)
 199 #endif
 200         {
 201           printf ("Error: The heap was allocated in upper memory.\n");
 202           exit (1);
 203         }
 204 #endif
 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 #ifndef CANNOT_DUMP
 265
 266 /* Recreate the heap from the data that was dumped to the executable.
 267    EXECUTABLE_PATH tells us where to find the executable.  */
 268 void
 269 recreate_heap (char *executable_path)
 270 {
 271   unsigned char *tmp;
 272
 273   /* First reserve the upper part of our heap.  (We reserve first
 274      because there have been problems in the past where doing the
 275      mapping first has loaded DLLs into the VA space of our heap.)  */
 276   tmp = VirtualAlloc ((void *) get_heap_end (),
 277                       get_reserved_heap_size () - get_committed_heap_size (),
 278                       MEM_RESERVE,
 279                       PAGE_NOACCESS);
 280   if (!tmp)
 281     exit (1);
 282
 283   /* We read in the data for the .bss section from the executable
 284      first and map in the heap from the executable second to prevent
 285      any funny interactions between file I/O and file mapping.  */
 286   read_in_bss (executable_path);
 287   map_in_heap (executable_path);
 288
 289   /* Update system version information to match current system.  */
 290   cache_system_info ();
 291 }
 292 #endif /* CANNOT_DUMP */
 293
 294 /* Round the heap up to the given alignment.  */
 295 void
 296 round_heap (unsigned long align)
 297 {
 298   unsigned long needs_to_be;
 299   unsigned long need_to_alloc;
 300
 301   needs_to_be = (unsigned long) round_to_next (get_heap_end (), align);
 302   need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
 303
 304   if (need_to_alloc)
 305     sbrk (need_to_alloc);
 306 }
 307
 308 #if (_MSC_VER >= 1000)
 309
 310 /* MSVC 4.2 invokes these functions from mainCRTStartup to initialize
 311    a heap via HeapCreate.  They are normally defined by the runtime,
 312    but we override them here so that the unnecessary HeapCreate call
 313    is not performed.  */
 314
 315 int __cdecl
 316 _heap_init (void)
 317 {
 318   /* Stepping through the assembly indicates that mainCRTStartup is
 319      expecting a nonzero success return value.  */
 320   return 1;
 321 }
 322
 323 void __cdecl
 324 _heap_term (void)
 325 {
 326   return;
 327 }
 328
 329 #endif