[bpt/emacs.git] / src / w32heap.c

/* Heap management routines for GNU Emacs on Windows NT.
   Copyright (C) 1994 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.

   Geoff Voelker (voelker@cs.washington.edu)			     7-29-94
*/

#include "config.h"

#include <stdlib.h>
#include <stdio.h>

#include "ntheap.h"
#include "lisp.h"  /* for VALMASK */

/* This gives us the page size and the size of the allocation unit on NT.  */
SYSTEM_INFO sysinfo_cache;
unsigned long syspage_mask = 0;

/* These are defined to get Emacs to compile, but are not used.  */
int edata;
int etext;

/* The major and minor versions of NT.  */
int nt_major_version;
int nt_minor_version;

/* Cache information describing the NT system for later use.  */
void
cache_system_info (void)
{
  union 
    {
      struct info 
	{
	  char  major;
	  char  minor;
	  short platform;
	} info;
      DWORD data;
    } version;

  /* Cache the version of the operating system.  */
  version.data = GetVersion ();
  nt_major_version = version.info.major;
  nt_minor_version = version.info.minor;

  /* Cache page size, allocation unit, processor type, etc.  */
  GetSystemInfo (&sysinfo_cache);
  syspage_mask = sysinfo_cache.dwPageSize - 1;
}

/* Round ADDRESS up to be aligned with ALIGN.  */
unsigned char *
round_to_next (unsigned char *address, unsigned long align)
{
  unsigned long tmp;

  tmp = (unsigned long) address;
  tmp = (tmp + align - 1) / align;

  return (unsigned char *) (tmp * align);
}

/* Info for keeping track of our heap.  */
unsigned char *data_region_base = NULL;
unsigned char *data_region_end = NULL;
unsigned char *real_data_region_end = NULL;
unsigned long  data_region_size = 0;
unsigned long  reserved_heap_size = 0;

/* The start of the data segment.  */
unsigned char *
get_data_start (void)
{
  return data_region_base;
}

/* The end of the data segment.  */
unsigned char *
get_data_end (void)
{
  return data_region_end;
}

static char *
allocate_heap (void)
{
  /* The base address for our GNU malloc heap is chosen in conjuction
     with the link settings for temacs.exe which control the stack size,
     the initial default process heap size and the executable image base
     address.  The link settings and the malloc heap base below must all
     correspond; the relationship between these values depends on how NT
     and Win95 arrange the virtual address space for a process (and on
     the size of the code and data segments in temacs.exe).

     The most important thing is to make base address for the executable
     image high enough to leave enough room between it and the 4MB floor
     of the process address space on Win95 for the primary thread stack,
     the process default heap, and other assorted odds and ends
     (eg. environment strings, private system dll memory etc) that are
     allocated before temacs has a chance to grab its malloc arena.  The
     malloc heap base can then be set several MB higher than the
     executable image base, leaving enough room for the code and data
     segments.

     Because some parts of Emacs can use rather a lot of stack space
     (for instance, the regular expression routines can potentially
     allocate several MB of stack space) we allow 8MB for the stack.

     Allowing 1MB for the default process heap, and 1MB for odds and
     ends, we can base the executable at 16MB and still have a generous
     safety margin.  At the moment, the executable has about 810KB of
     code (for x86) and about 550KB of data - on RISC platforms the code
     size could be roughly double, so if we allow 4MB for the executable
     we will have plenty of room for expansion.

     Thus we would like to set the malloc heap base to 20MB.  However,
     Win95 refuses to allocate the heap starting at this address, so we
     set the base to 27MB to make it happy.  Since Emacs now leaves
     28 bits available for pointers, this lets us use the remainder of
     the region below the 256MB line for our malloc arena - 229MB is
     still a pretty decent arena to play in!  */

  unsigned long base = 0x01B00000;   /*  27MB */
  unsigned long end  = 1 << VALBITS; /* 256MB */
  void *ptr = NULL;

#ifdef NTHEAP_PROBE_BASE
  while (!ptr && (base < end))
    {
#endif
      reserved_heap_size = end - base;
      ptr = VirtualAlloc ((void *) base,
			  get_reserved_heap_size (),
			  MEM_RESERVE,
			  PAGE_NOACCESS);
#ifdef NTHEAP_PROBE_BASE
      base += 0x00100000;  /* 1MB increment */
    }
#endif
  return ptr;
}


/* Emulate Unix sbrk.  */
void *
sbrk (unsigned long increment)
{
  void *result;
  long size = (long) increment;
  
  /* Allocate our heap if we haven't done so already.  */
  if (!data_region_base) 
    {
      data_region_base = allocate_heap ();
      if (!data_region_base)
	return NULL;

      /* Ensure that the addresses don't use the upper tag bits since
	 the Lisp type goes there.  */
      if (((unsigned long) data_region_base & ~VALMASK) != 0) 
	{
	  printf ("Error: The heap was allocated in upper memory.\n");
	  exit (1);
	}

      data_region_end = data_region_base;
      real_data_region_end = data_region_end;
      data_region_size = get_reserved_heap_size ();
    }
  
  result = data_region_end;
  
  /* If size is negative, shrink the heap by decommitting pages.  */
  if (size < 0) 
    {
      int new_size;
      unsigned char *new_data_region_end;

      size = -size;

      /* Sanity checks.  */
      if ((data_region_end - size) < data_region_base)
	return NULL;

      /* We can only decommit full pages, so allow for 
	 partial deallocation [cga].  */
      new_data_region_end = (data_region_end - size);
      new_data_region_end = (unsigned char *)
	((long) (new_data_region_end + syspage_mask) & ~syspage_mask);
      new_size = real_data_region_end - new_data_region_end;
      real_data_region_end = new_data_region_end;
      if (new_size > 0) 
	{
	  /* Decommit size bytes from the end of the heap.  */
	  if (!VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT))
	    return NULL;
 	}

      data_region_end -= size;
    } 
  /* If size is positive, grow the heap by committing reserved pages.  */
  else if (size > 0) 
    {
      /* Sanity checks.  */
      if ((data_region_end + size) >
	  (data_region_base + get_reserved_heap_size ()))
	return NULL;

      /* Commit more of our heap. */
      if (VirtualAlloc (data_region_end, size, MEM_COMMIT,
			PAGE_READWRITE) == NULL)
	return NULL;
      data_region_end += size;

      /* We really only commit full pages, so record where
	 the real end of committed memory is [cga].  */
      real_data_region_end = (unsigned char *)
	  ((long) (data_region_end + syspage_mask) & ~syspage_mask);
    }
  
  return result;
}

/* Recreate the heap from the data that was dumped to the executable.
   EXECUTABLE_PATH tells us where to find the executable.  */
void
recreate_heap (char *executable_path)
{
  unsigned char *tmp;

  /* First reserve the upper part of our heap.  (We reserve first
     because there have been problems in the past where doing the
     mapping first has loaded DLLs into the VA space of our heap.)  */
  tmp = VirtualAlloc ((void *) get_heap_end (),
		      get_reserved_heap_size () - get_committed_heap_size (),
		      MEM_RESERVE,
		      PAGE_NOACCESS);
  if (!tmp)
    exit (1);

  /* We read in the data for the .bss section from the executable
     first and map in the heap from the executable second to prevent
     any funny interactions between file I/O and file mapping.  */
  read_in_bss (executable_path);
  map_in_heap (executable_path);
}

/* Round the heap up to the given alignment.  */
void
round_heap (unsigned long align)
{
  unsigned long needs_to_be;
  unsigned long need_to_alloc;
  
  needs_to_be = (unsigned long) round_to_next (get_heap_end (), align);
  need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
  
  if (need_to_alloc) 
    sbrk (need_to_alloc);
}
Commit	Line	Data
95ed0025 RS	1	/* Heap management routines for GNU Emacs on Windows NT.
	2	Copyright (C) 1994 Free Software Foundation, Inc.
	3
3b7ad313	4	This file is part of GNU Emacs.
95ed0025	5
3b7ad313 EN	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.
95ed0025	10
3b7ad313 EN	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.
95ed0025	15
3b7ad313 EN	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.
95ed0025 RS	20
	21	Geoff Voelker (voelker@cs.washington.edu) 7-29-94
	22	*/
	23
3bbabc43 GV	24	#include "config.h"
3bbabc43 GV	25
95ed0025 RS	26	#include <stdlib.h>
	27	#include <stdio.h>
	28
	29	#include "ntheap.h"
8dfdd41f	30	#include "lisp.h" /* for VALMASK */
95ed0025 RS	31
	32	/* This gives us the page size and the size of the allocation unit on NT. */
	33	SYSTEM_INFO sysinfo_cache;
3bbabc43	34	unsigned long syspage_mask = 0;
95ed0025 RS	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);
3bbabc43	66	syspage_mask = sysinfo_cache.dwPageSize - 1;
95ed0025 RS	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;
3bbabc43	84	unsigned char *real_data_region_end = NULL;
95ed0025	85	unsigned long data_region_size = 0;
011db670	86	unsigned long reserved_heap_size = 0;
95ed0025 RS	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
011db670 GV	102	static char *
	103	allocate_heap (void)
	104	{
8dfdd41f GV	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
709fd16b GV	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
8dfdd41f	137	28 bits available for pointers, this lets us use the remainder of
709fd16b GV	138	the region below the 256MB line for our malloc arena - 229MB is
709fd16b GV	139	still a pretty decent arena to play in! */
8dfdd41f	140
709fd16b	141	unsigned long base = 0x01B00000; /* 27MB */
8dfdd41f	142	unsigned long end = 1 << VALBITS; /* 256MB */
709fd16b	143	void *ptr = NULL;
011db670	144
709fd16b GV	145	#ifdef NTHEAP_PROBE_BASE
	146	while (!ptr && (base < end))
	147	{
	148	#endif
	149	reserved_heap_size = end - base;
	150	ptr = VirtualAlloc ((void *) base,
	151	get_reserved_heap_size (),
	152	MEM_RESERVE,
	153	PAGE_NOACCESS);
	154	#ifdef NTHEAP_PROBE_BASE
	155	base += 0x00100000; /* 1MB increment */
	156	}
	157	#endif
	158	return ptr;
011db670	159	}
011db670 GV	160
011db670 GV	161
95ed0025 RS	162	/* Emulate Unix sbrk. */
	163	void *
	164	sbrk (unsigned long increment)
	165	{
	166	void *result;
	167	long size = (long) increment;
	168
	169	/* Allocate our heap if we haven't done so already. */
	170	if (!data_region_base)
	171	{
011db670	172	data_region_base = allocate_heap ();
95ed0025 RS	173	if (!data_region_base)
	174	return NULL;
	175
8dfdd41f GV	176	/* Ensure that the addresses don't use the upper tag bits since
	177	the Lisp type goes there. */
	178	if (((unsigned long) data_region_base & ~VALMASK) != 0)
95ed0025 RS	179	{
	180	printf ("Error: The heap was allocated in upper memory.\n");
	181	exit (1);
	182	}
	183
	184	data_region_end = data_region_base;
3bbabc43	185	real_data_region_end = data_region_end;
95ed0025 RS	186	data_region_size = get_reserved_heap_size ();
	187	}
	188
	189	result = data_region_end;
	190
	191	/* If size is negative, shrink the heap by decommitting pages. */
	192	if (size < 0)
	193	{
3bbabc43 GV	194	int new_size;
	195	unsigned char *new_data_region_end;
	196
95ed0025 RS	197	size = -size;
	198
	199	/* Sanity checks. */
95ed0025 RS	200	if ((data_region_end - size) < data_region_base)
	201	return NULL;
	202
3bbabc43 GV	203	/* We can only decommit full pages, so allow for
	204	partial deallocation [cga]. */
	205	new_data_region_end = (data_region_end - size);
	206	new_data_region_end = (unsigned char *)
	207	((long) (new_data_region_end + syspage_mask) & ~syspage_mask);
	208	new_size = real_data_region_end - new_data_region_end;
	209	real_data_region_end = new_data_region_end;
	210	if (new_size > 0)
	211	{
	212	/* Decommit size bytes from the end of the heap. */
	213	if (!VirtualFree (real_data_region_end, new_size, MEM_DECOMMIT))
	214	return NULL;
	215	}
95ed0025 RS	216
	217	data_region_end -= size;
	218	}
	219	/* If size is positive, grow the heap by committing reserved pages. */
	220	else if (size > 0)
	221	{
	222	/* Sanity checks. */
95ed0025 RS	223	if ((data_region_end + size) >
	224	(data_region_base + get_reserved_heap_size ()))
	225	return NULL;
	226
	227	/* Commit more of our heap. */
	228	if (VirtualAlloc (data_region_end, size, MEM_COMMIT,
	229	PAGE_READWRITE) == NULL)
	230	return NULL;
	231	data_region_end += size;
3bbabc43 GV	232
	233	/* We really only commit full pages, so record where
	234	the real end of committed memory is [cga]. */
	235	real_data_region_end = (unsigned char *)
	236	((long) (data_region_end + syspage_mask) & ~syspage_mask);
95ed0025 RS	237	}
	238
	239	return result;
	240	}
	241
	242	/* Recreate the heap from the data that was dumped to the executable.
	243	EXECUTABLE_PATH tells us where to find the executable. */
	244	void
	245	recreate_heap (char *executable_path)
	246	{
	247	unsigned char *tmp;
	248
	249	/* First reserve the upper part of our heap. (We reserve first
	250	because there have been problems in the past where doing the
	251	mapping first has loaded DLLs into the VA space of our heap.) */
	252	tmp = VirtualAlloc ((void *) get_heap_end (),
	253	get_reserved_heap_size () - get_committed_heap_size (),
	254	MEM_RESERVE,
	255	PAGE_NOACCESS);
	256	if (!tmp)
	257	exit (1);
	258
	259	/* We read in the data for the .bss section from the executable
	260	first and map in the heap from the executable second to prevent
	261	any funny interactions between file I/O and file mapping. */
	262	read_in_bss (executable_path);
	263	map_in_heap (executable_path);
	264	}
	265
	266	/* Round the heap up to the given alignment. */
	267	void
	268	round_heap (unsigned long align)
	269	{
	270	unsigned long needs_to_be;
	271	unsigned long need_to_alloc;
	272
	273	needs_to_be = (unsigned long) round_to_next (get_heap_end (), align);
	274	need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
	275
	276	if (need_to_alloc)
	277	sbrk (need_to_alloc);
	278	}