xemacs-beta: src/ralloc.c comparison

comparison src/ralloc.c @ 412:697ef44129c6 r21-2-14

Import from CVS: tag r21-2-14

author	cvs
date	Mon, 13 Aug 2007 11:20:41 +0200
parents	a86b2b5e0111
children	11054d720c21

comparison

equal deleted inserted replaced

-:12e008d41344
+:697ef44129c6
 #endif /* 0 */
 /* Unconditionally use unsigned char * for this.  */
 typedef unsigned char *POINTER;
+typedef unsigned long SIZE;
 #ifdef DOUG_LEA_MALLOC
 #define M_TOP_PAD -2
 #include <malloc.h>
 #endif
 #else	/* Not emacs.  */
 #include <stddef.h>
+typedef size_t SIZE;
 typedef void *POINTER;
 #include <unistd.h>
 #include <malloc.h>
 #include <string.h>
 #endif	/* emacs.  */
 void init_ralloc (void);
+#define safe_bcopy(x, y, z) memmove (y, x, z)
 #define NIL ((POINTER) 0)
 #if !defined(HAVE_MMAP) || defined(DOUG_LEA_MALLOC)
 /* Declarations for working with the malloc, ralloc, and system breaks.  */
 /* Function to set the real break value. */
-static POINTER (*real_morecore) (ptrdiff_t size);
+static POINTER (*real_morecore) (long size);
 /* The break value, as seen by malloc (). */
 static POINTER virtual_break_value;
 /* The break value, viewed by the relocatable blocs. */
 {
 struct bp *next;
 struct bp *prev;
 POINTER *variable;
 POINTER data;
-size_t size;
+SIZE size;
 POINTER new_data;		/* temporarily used for relocation */
 struct heap *heap; 		/* Heap this bloc is in.  */
 } *bloc_ptr;
 #define NIL_BLOC ((bloc_ptr) 0)
 Return the address of the space if all went well, or zero if we couldn't
 allocate the memory.  */
 static POINTER
-obtain (POINTER address, size_t size)
+obtain (POINTER address, SIZE size)
 {
 heap_ptr heap;
-size_t already_available;
+SIZE already_available;
 /* Find the heap that ADDRESS falls within.  */
 for (heap = last_heap; heap; heap = heap->prev)
 {
 if (heap->start <= address && address <= heap->end)
 /* If we can't fit them within any existing heap,
 get more space.  */
 if (heap == NIL_HEAP)
 {
 POINTER new = (*real_morecore)(0);
-size_t get;
+SIZE get;
 already_available = (char *)last_heap->end - (char *)address;
 if (new != last_heap->end)
 	{
 #if 0
 /* Obtain SIZE bytes of space and return a pointer to the new area.
 If we could not allocate the space, return zero.  */
 static POINTER
-get_more_space (size_t size)
+get_more_space (SIZE size)
 {
 POINTER ptr = break_value;
 if (obtain (size))
 return ptr;
 else
 /* Note that SIZE bytes of space have been relinquished by the process.
 If SIZE is more than a page, return the space to the system. */
 static void
-relinquish (void)
+relinquish ()
 {
 register heap_ptr h;
 int excess = 0;
 /* Add the amount of space beyond break_value
 /* Return the total size in use by relocating allocator,
 above where malloc gets space.  */
 long r_alloc_size_in_use (void);
 long
-r_alloc_size_in_use (void)
+r_alloc_size_in_use ()
 {
 return break_value - virtual_break_value;
 }
 /* The meat - allocating, freeing, and relocating blocs.  */
 /* Allocate a bloc of SIZE bytes and append it to the chain of blocs.
 Returns a pointer to the new bloc, or zero if we couldn't allocate
 memory for the new block.  */
 static bloc_ptr
-get_bloc (size_t size)
+get_bloc (SIZE size)
 {
 register bloc_ptr new_bloc;
 register heap_ptr heap;
 if (! (new_bloc = (bloc_ptr) malloc (BLOC_PTR_SIZE))
 /* If BLOC won't fit in any heap,
 	 get enough new space to hold BLOC and all following blocs.  */
 if (heap == NIL_HEAP)
 	{
 	  register bloc_ptr tb = b;
-	  register size_t s = 0;
+	  register SIZE s = 0;
 	  /* Add up the size of all the following blocs.  */
 	  while (tb != NIL_BLOC)
 	    {
 	      if (tb->variable)
 /* Resize BLOC to SIZE bytes.  This relocates the blocs
 that come after BLOC in memory.  */
 static int
-resize_bloc (bloc_ptr bloc, size_t size)
+resize_bloc (bloc_ptr bloc, SIZE size)
 {
 register bloc_ptr b;
 heap_ptr heap;
 POINTER address;
-size_t old_size;
+SIZE old_size;
 /* No need to ever call this if arena is frozen, bug somewhere!  */
 if (r_alloc_freeze_level)
 abort();
 	      b->size = 0;
 	      b->data = b->new_data;
 }
 	  else
 	    {
-	      memmove (b->new_data, b->data, b->size);
+	      safe_bcopy (b->data, b->new_data, b->size);
 	      *b->variable = b->data = b->new_data;
 }
 	}
 if (!bloc->variable)
 	{
 	  bloc->size = 0;
 	  bloc->data = bloc->new_data;
 	}
 else
 	{
-	  memmove (bloc->new_data, bloc->data, old_size);
+	  safe_bcopy (bloc->data, bloc->new_data, old_size);
 	  memset (bloc->new_data + old_size, 0, size - old_size);
 	  *bloc->variable = bloc->data = bloc->new_data;
 	}
 }
 else
 	      b->size = 0;
 	      b->data = b->new_data;
 }
 	  else
 	    {
-	      memmove (b->new_data, b->data, b->size);
+	      safe_bcopy (b->data, b->new_data, b->size);
 	      *b->variable = b->data = b->new_data;
 	    }
 	}
 }
 If we're out of memory, we should return zero, to imitate the other
 __morecore hook values - in particular, __default_morecore in the
 GNU malloc package.  */
-POINTER r_alloc_sbrk (ptrdiff_t size);
+POINTER r_alloc_sbrk (long size);
 POINTER
-r_alloc_sbrk (ptrdiff_t size)
+r_alloc_sbrk (long size)
 {
 register bloc_ptr b;
 POINTER address;
 if (! r_alloc_initialized)
 /* Allocate a page-aligned space.  GNU malloc would reclaim an
 	 extra space if we passed an unaligned one.  But we could
 	 not always find a space which is contiguous to the previous.  */
 POINTER new_bloc_start;
 heap_ptr h = first_heap;
-size_t get = ROUNDUP (size);
+SIZE get = ROUNDUP (size);
 address = (POINTER) ROUNDUP (virtual_break_value);
 /* Search the list upward for a heap which is large enough.  */
 while ((char *) h->end < (char *) MEM_ROUNDUP ((char *)address + get))
 	  /* Note that (POINTER)(h+1) <= new_bloc_start since
 	     get >= page_size, so the following does not destroy the heap
 	     header.  */
 	  for (b = last_bloc; b != NIL_BLOC; b = b->prev)
 	    {
-	      memmove (b->new_data, b->data, b->size);
+	      safe_bcopy (b->data, b->new_data, b->size);
 	      *b->variable = b->data = b->new_data;
 	    }
 	  h->bloc_start = new_bloc_start;
 memset (address, 0, size);
 }
 else /* size < 0 */
 {
-size_t excess = (char *)first_heap->bloc_start
+SIZE excess = (char *)first_heap->bloc_start
 		      - ((char *)virtual_break_value + size);
 address = virtual_break_value;
 if (r_alloc_freeze_level == 0 && excess > 2 * extra_bytes)
 	  relocate_blocs (first_bloc, first_heap, first_heap->bloc_start);
 	  for (b = first_bloc; b != NIL_BLOC; b = b->next)
 	    {
-	      memmove (b->new_data, b->data, b->size);
+	      safe_bcopy (b->data, b->new_data, b->size);
 	      *b->variable = b->data = b->new_data;
 	    }
 	}
 if ((char *)virtual_break_value + size < (char *)first_heap->start)
 before allocating a new area.  Not yet done.
 If we can't allocate the necessary memory, set *PTR to zero, and
 return zero.  */
-POINTER r_alloc (POINTER *ptr, size_t size);
+POINTER r_alloc (POINTER *ptr, SIZE size);
 POINTER
-r_alloc (POINTER *ptr, size_t size)
+r_alloc (POINTER *ptr, SIZE size)
 {
 bloc_ptr new_bloc;
 if (! r_alloc_initialized)
 init_ralloc ();
 Change *PTR to reflect the new bloc, and return this value.
 If more memory cannot be allocated, then leave *PTR unchanged, and
 return zero.  */
-POINTER r_re_alloc (POINTER *ptr, size_t size);
+POINTER r_re_alloc (POINTER *ptr, SIZE size);
 POINTER
-r_re_alloc (POINTER *ptr, size_t size)
+r_re_alloc (POINTER *ptr, SIZE size)
 {
 register bloc_ptr bloc;
 if (! r_alloc_initialized)
 init_ralloc ();
 r_alloc_sbrk (-size);
 }
 void r_alloc_thaw (void);
 void
-r_alloc_thaw (void)
+r_alloc_thaw ()
 {
 if (! r_alloc_initialized)
 init_ralloc ();
 if (--r_alloc_freeze_level < 0)
 abort ();
 /* This frees all unused blocs.  It is not too inefficient, as the resize
-and memmove is done only once.  Afterwards, all unreferenced blocs are
+and bcopy is done only once.  Afterwards, all unreferenced blocs are
 already shrunk to zero size.  */
 if (!r_alloc_freeze_level)
 {
 bloc_ptr *b = &first_bloc;
 while (*b)
 /* The hook `malloc' uses for the function which gets more space
 from the system.  */
 #ifndef DOUG_LEA_MALLOC
-extern POINTER (*__morecore) (ptrdiff_t size);
+extern POINTER (*__morecore) (long size);
 #endif
 /* Initialize various things for memory allocation. */
+#define SET_FUN_PTR(fun_ptr, fun_val) \
+(*((void **) (&fun_ptr)) = ((void *) (fun_val)))
 void
 init_ralloc (void)
 {
 if (r_alloc_initialized)
 return;
 r_alloc_initialized = 1;
-real_morecore = (POINTER (*) (ptrdiff_t)) __morecore;
+SET_FUN_PTR (real_morecore, __morecore);
-__morecore =
+SET_FUN_PTR (__morecore, r_alloc_sbrk);
-#ifdef __GNUC__
-(__typeof__ (__morecore))
-#endif
-r_alloc_sbrk;
 first_heap = last_heap = &heap_base;
 first_heap->next = first_heap->prev = NIL_HEAP;
 first_heap->start = first_heap->bloc_start
 = virtual_break_value = break_value = (*real_morecore) (0);
 /* Reinitialize the morecore hook variables after restarting a dumped
 Emacs.  This is needed when using Doug Lea's malloc from GNU libc.  */
 void r_alloc_reinit (void);
 void
-r_alloc_reinit (void)
+r_alloc_reinit ()
 {
 /* Only do this if the hook has been reset, so that we don't get an
 infinite loop, in case Emacs was linked statically.  */
-if ( (POINTER (*) (ptrdiff_t)) __morecore !=  r_alloc_sbrk)
+if ( ((void*) __morecore) !=  (void *) (r_alloc_sbrk))
 {
-real_morecore = (POINTER (*) (ptrdiff_t)) __morecore;
+SET_FUN_PTR (real_morecore, __morecore);
-__morecore =
+SET_FUN_PTR (__morecore, r_alloc_sbrk);
-#ifdef __GNUC__
-	(__typeof__ (__morecore))
-#endif
-	r_alloc_sbrk;
 }
 }
 #if 0
 #ifdef DEBUG
 void
-r_alloc_check (void)
+r_alloc_check ()
 {
 int found = 0;
 heap_ptr h, ph = 0;
 bloc_ptr b, pb = 0;
 for (b = first_bloc; b; b = b->next)
 {
 assert (b->prev == pb);
 assert ((POINTER) MEM_ROUNDUP (b->data) == b->data);
-assert ((size_t) MEM_ROUNDUP (b->size) == b->size);
+assert ((SIZE) MEM_ROUNDUP (b->size) == b->size);
 ph = 0;
 for (h = first_heap; h; h = h->next)
 	{
 	  if (h->bloc_start <= b->data && b->data + b->size <= h->end)
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <stdio.h>
 typedef void *VM_ADDR;		/* VM addresses */
-static const VM_ADDR VM_FAILURE_ADDR = (VM_ADDR) -1; /* mmap returns this when it fails. */
+static CONST VM_ADDR VM_FAILURE_ADDR = (VM_ADDR) -1; /* mmap returns this when it fails. */
 /* Configuration for relocating allocator. */
 /* #define MMAP_GENERATE_ADDRESSES */
 /* Define this if you want Emacs to manage the address table.
 /* Initialization procedure for address picking scheme */
 static void Addr_Block_initialize(void);
 /* Get a suitable VM_ADDR via mmap */
-static VM_ADDR New_Addr_Block (size_t sz);
+static VM_ADDR New_Addr_Block( SIZE sz );
 /* Free a VM_ADDR allocated via New_Addr_Block */
-static void Free_Addr_Block (VM_ADDR addr, size_t sz);
+static void Free_Addr_Block( VM_ADDR addr, SIZE sz );
 #ifdef MMAP_GENERATE_ADDRESSES
 /* Implementation of the three calls for address picking when XEmacs is incharge */
 /* The enum denotes the status of the following block. */
 typedef enum { empty = 0, occupied, unavailable } addr_status;
 typedef struct addr_chain
 {
 POINTER addr;
-size_t sz;
+SIZE sz;
 addr_status flag;
 struct addr_chain *next;
 } ADDRESS_BLOCK, *ADDRESS_CHAIN;
 /* NB: empty and unavailable blocks are concatenated. */
 /* Start off the address block chain with a humongous address block
 which is empty to start with.  Note that addr_chain is invariant
 WRT the addition/deletion of address blocks because of the assert
 in Coalesce() and the strict ordering of blocks by their address
 */
-static void
+static void Addr_Block_initialize()
-Addr_Block_initialize (void)
 {
 MEMMETER( MVAL( M_Addrlist_Size )++)
 addr_chain = (ADDRESS_CHAIN) UNDERLYING_MALLOC( sizeof( ADDRESS_BLOCK ));
 addr_chain->next = 0;		/* Last block in chain */
 addr_chain->sz = 0x0c000000;	/* Size */
-addr_chain->addr = (POINTER) (0x04000000);
+addr_chain->addr = (POINTER) (0x04000000 | DATA_SEG_BITS);
 addr_chain->flag = empty;
 }
 /* Coalesce address blocks if they are contiguous.  Only empty and
 unavailable slots are coalesced. */
-static void
+static void Coalesce_Addr_Blocks()
-Coalesce_Addr_Blocks (void)
 {
 ADDRESS_CHAIN p;
 for (p = addr_chain; p; p = p->next)
 {
 while (p->next && p->flag == p->next->flag)
 	}
 } /* for all p */
 }
 /* Get an empty address block of specified size. */
-static VM_ADDR
+static VM_ADDR New_Addr_Block( SIZE sz )
-New_Addr_Block (size_t sz)
 {
 ADDRESS_CHAIN p = addr_chain;
 VM_ADDR new_addr = VM_FAILURE_ADDR;
 for (; p; p = p->next)
 {
 return new_addr;
 }
 /* Free an address block.  We mark the block as being empty, and attempt to
 do any coalescing that may have resulted from this. */
-static void
+static void Free_Addr_Block( VM_ADDR addr, SIZE sz )
-Free_Addr_Block (VM_ADDR addr, size_t sz)
 {
 ADDRESS_CHAIN p = addr_chain;
 for (; p; p = p->next )
 {
 if (p->addr == addr)
 }
 #else /* !MMAP_GENERATE_ADDRESSES */
 /* This is an alternate (simpler) implementation in cases where the
 address is picked by the kernel. */
-static void
+static void Addr_Block_initialize(void)
-Addr_Block_initialize (void)
 {
 /* Nothing. */
 }
-static VM_ADDR
+static VM_ADDR New_Addr_Block( SIZE sz )
-New_Addr_Block (size_t sz)
 {
 return mmap (0, sz, PROT_READ|PROT_WRITE, MAP_FLAGS,
 	       DEV_ZERO_FD, 0 );
 }
-static void
+static void Free_Addr_Block( VM_ADDR addr, SIZE sz )
-Free_Addr_Block (VM_ADDR addr, size_t sz)
 {
 munmap ((caddr_t) addr, sz );
 }
 #endif /* MMAP_GENERATE_ADDRESSES */
 /* IMPLEMENTATION OF EXPORTED RELOCATOR INTERFACE */
 /*
-r_alloc (POINTER, SIZE): Allocate a relocatable area with the start
+r_alloc( POINTER, SIZE ): Allocate a relocatable area with the start
 address aliased to the first parameter.
 */
-POINTER r_alloc (POINTER *ptr, size_t size);
+POINTER r_alloc (POINTER *ptr, SIZE size);
 POINTER
-r_alloc (POINTER *ptr, size_t size)
+r_alloc (POINTER *ptr, SIZE size)
 {
 MMAP_HANDLE mh;
 switch(r_alloc_initialized)
 {
 break;
 default:
 mh = new_mmap_handle( size );
 if (mh)
 	{
-	  size_t hysteresis = (mmap_hysteresis > 0 ?  mmap_hysteresis  : 0);
+	  SIZE hysteresis = (mmap_hysteresis > 0 ?  mmap_hysteresis  : 0);
-	  size_t mmapped_size = ROUNDUP( size + hysteresis );
+	  SIZE  mmapped_size = ROUNDUP( size + hysteresis );
 	  MEMMETER( MVAL(M_Map)++ )
 	  MEMMETER( MVAL(M_Pages_Map) += (mmapped_size/page_size) )
 	  MEMMETER( MVAL(M_Wastage) += mmapped_size - size )
 MEMMETER( MVAL(M_Live_Pages) += (mmapped_size/page_size) )
 	  mh->vm_addr = New_Addr_Block( mmapped_size );
 Change *PTR to reflect the new bloc, and return this value.
 If more memory cannot be allocated, then leave *PTR unchanged, and
 return zero.  */
-POINTER r_re_alloc (POINTER *ptr, size_t sz);
+POINTER r_re_alloc (POINTER *ptr, SIZE sz);
 POINTER
-r_re_alloc (POINTER *ptr, size_t sz)
+r_re_alloc (POINTER *ptr, SIZE sz)
 {
 if (r_alloc_initialized == 0)
 {
 abort ();
 return 0; /* suppress compiler warning */
 	*ptr = tmp;
 return tmp;
 }
 else
 {
-size_t hysteresis = (mmap_hysteresis > 0 ?  mmap_hysteresis : 0);
+SIZE hysteresis = (mmap_hysteresis > 0 ?  mmap_hysteresis : 0);
-size_t actual_sz = ROUNDUP( sz + hysteresis );
+SIZE actual_sz = ROUNDUP( sz + hysteresis );
 MMAP_HANDLE h = find_mmap_handle( ptr );
 VM_ADDR new_vm_addr;
 if ( h == 0 )		/* Was allocated using malloc. */
 	{

Mercurial > hg > xemacs-beta

comparison src/ralloc.c @ 412:697ef44129c6 r21-2-14