* cygheap.cc (cygheap_fixup_in_child): Clear cygheap->base so that heap is not

forced to start at the same place in execed process.
* heap.cc: Remove brk* macros for clarity throughout.
* heap.h: Ditto.
* shared.cc (shared_info::initialize): Move heap_chunk test into
heap_chunk_size().
(heap_chunk_size): Check for chunk size here.  Don't go to registry if
heap_chunk_in_mb is already set.
* smallprint.c (console_printf): Add Windows 95 concessions.

winsup/cygwin/ChangeLog

@@ -1,3 +1,16 @@
+Sun Sep  9 15:02:44 2001  Christopher Faylor <cgf@cygnus.com>
+
+	* cygheap.cc (cygheap_fixup_in_child): Clear cygheap->base so that heap
+	is not forced to start at the same place in execed process.
+	* heap.cc: Remove brk* macros for clarity throughout.
+	* heap.h: Ditto.
+	* shared.cc (shared_info::initialize): Move heap_chunk test into
+	heap_chunk_size().
+	(heap_chunk_size): Check for chunk size here.  Don't go to registry if
+	heap_chunk_in_mb is already set.
+
+	* smallprint.c (console_printf): Add Windows 95 concessions.
+
 Sun Sep  9 13:01:06 2001  Christopher Faylor <cgf@cygnus.com>
 
 	* child_info.h (PROC_MAGIC): Bump magic number.

winsup/cygwin/cygheap.cc

@@ -132,6 +132,7 @@ cygheap_fixup_in_child (child_info *ci, bool execed)
 
   if (execed)
     {
+      cygheap->heapbase = NULL;		/* We can allocate the heap anywhere */
       /* Walk the allocated memory chain looking for orphaned memory from
 	 previous execs */
       for (_cmalloc_entry *rvc = cygheap->chain; rvc; rvc = rvc->prev)

winsup/cygwin/cygheap.h

@@ -153,9 +153,12 @@ struct init_cygheap
 {
   _cmalloc_entry *chain;
   char *buckets[32];
-  void *heapbase;
+  struct /* User heap stuff. */
-  void *heapptr;
+    {
-  void *heaptop;
+      void *heapbase;
+      void *heapptr;
+      void *heaptop;
+    };
   cygheap_root root;
   cygheap_user user;
   mode_t umask;

winsup/cygwin/heap.cc

@@ -36,11 +36,11 @@ heap_init ()
      as our parent.  If not, we don't care where it ends up.  */
 
   page_const = system_info.dwPageSize;
-  if (brkbase)
+  if (cygheap->heapbase)
     {
-      DWORD chunk = brkchunk;	/* allocation chunk */
+      DWORD chunk = cygwin_shared->heap_chunk_size ();	/* allocation chunk */
       /* total size commited in parent */
-      DWORD allocsize = (char *) brktop - (char *) brkbase;
+      DWORD allocsize = (char *) cygheap->heaptop - (char *) cygheap->heapbase;
       /* round up by chunk size */
       DWORD reserve_size = chunk * ((allocsize + (chunk - 1)) / chunk);
 
@@ -48,7 +48,7 @@ heap_init ()
       char *p;
       for (;;)
 	{
-	  p = (char *) VirtualAlloc (brkbase, reserve_size,
+	  p = (char *) VirtualAlloc (cygheap->heapbase, reserve_size,
 				     MEM_RESERVE, PAGE_READWRITE);
 	  if (p)
 	    break;
@@ -57,23 +57,26 @@ heap_init ()
 	}
       if (p == NULL)
 	api_fatal ("1. unable to allocate heap %p, heap_chunk_size %d, pid %d, %E",
-		   brkbase, brkchunk, myself->pid);
+		   cygheap->heapbase, cygwin_shared->heap_chunk_size (), myself->pid);
-      if (p != brkbase)
+      if (p != cygheap->heapbase)
-	api_fatal ("heap allocated but not at %p", brkbase);
+	api_fatal ("heap allocated but not at %p", cygheap->heapbase);
-      if (! VirtualAlloc (brkbase, allocsize, MEM_COMMIT, PAGE_READWRITE))
+      if (! VirtualAlloc (cygheap->heapbase, allocsize, MEM_COMMIT, PAGE_READWRITE))
 	api_fatal ("MEM_COMMIT failed, %E");
     }
   else
     {
       /* Initialize page mask and default heap size.  Preallocate a heap
        * to assure contiguous memory.  */
-      brk = brktop = brkbase = VirtualAlloc(NULL, brkchunk, MEM_RESERVE, PAGE_NOACCESS);
+      cygheap->heapptr = cygheap->heaptop = cygheap->heapbase =
-      if (brkbase == NULL)
+	VirtualAlloc(NULL, cygwin_shared->heap_chunk_size (), MEM_RESERVE,
+	    	     PAGE_NOACCESS);
+      if (cygheap->heapbase == NULL)
 	api_fatal ("2. unable to allocate heap, heap_chunk_size %d, %E",
-		   brkchunk);
+		   cygwin_shared->heap_chunk_size ());
     }
 
-  debug_printf ("heap base %p, heap top %p", brkbase, brktop);
+  debug_printf ("heap base %p, heap top %p", cygheap->heapbase,
+      		cygheap->heaptop);
   page_const--;
   malloc_init ();
 }
@@ -90,43 +93,43 @@ _sbrk(int n)
   unsigned commitbytes, newbrksize;
 
   if (n == 0)
-    return brk;			/* Just wanted to find current brk address */
+    return cygheap->heapptr;			/* Just wanted to find current cygheap->heapptr address */
 
-  newbrk = (char *) brk + n;	/* Where new brk will be */
+  newbrk = (char *) cygheap->heapptr + n;	/* Where new cygheap->heapptr will be */
-  newtop = (char *) pround (newbrk); /* Actual top of allocated memory -
+  newtop = (char *) pround (newbrk);		/* Actual top of allocated memory -
-				   on page boundary */
+						   on page boundary */
 
-  if (newtop == brktop)
+  if (newtop == cygheap->heaptop)
     goto good;
 
   if (n < 0)
-    {				/* Freeing memory */
+    {						/* Freeing memory */
-      assert(newtop < brktop);
+      assert(newtop < cygheap->heaptop);
-      n = (char *) brktop - newtop;
+      n = (char *) cygheap->heaptop - newtop;
       if (VirtualFree(newtop, n, MEM_DECOMMIT)) /* Give it back to OS */
-	goto good;		/*  Didn't take */
+	goto good;				/*  Didn't take */
       else
 	goto err;
     }
 
-  assert(newtop > brktop);
+  assert(newtop > cygheap->heaptop);
 
   /* Need to grab more pages from the OS.  If this fails it may be because
    * we have used up previously reserved memory.  Or, we're just plumb out
    * of memory.  */
-  commitbytes = pround (newtop - (char *) brktop);
+  commitbytes = pround (newtop - (char *) cygheap->heaptop);
-  if (VirtualAlloc(brktop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL)
+  if (VirtualAlloc(cygheap->heaptop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL)
     goto good;
 
   /* Couldn't allocate memory.  Maybe we can reserve some more.
-     Reserve either the maximum of the standard brkchunk or the requested
+     Reserve either the maximum of the standard cygwin_shared->heap_chunk_size () or the requested
      amount.  Then attempt to actually allocate it.  */
 
-  if ((newbrksize = brkchunk) < commitbytes)
+  if ((newbrksize = cygwin_shared->heap_chunk_size ()) < commitbytes)
     newbrksize = commitbytes;
 
-  if ((VirtualAlloc(brktop, newbrksize, MEM_RESERVE, PAGE_NOACCESS) != NULL) &&
+  if ((VirtualAlloc(cygheap->heaptop, newbrksize, MEM_RESERVE, PAGE_NOACCESS) != NULL) &&
-      (VirtualAlloc(brktop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL))
+      (VirtualAlloc(cygheap->heaptop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL))
     goto good;
 
 err:
@@ -134,8 +137,8 @@ err:
   return (void *) -1;
 
 good:
-  void *oldbrk = brk;
+  void *oldbrk = cygheap->heapptr;
-  brk = newbrk;
+  cygheap->heapptr = newbrk;
-  brktop = newtop;
+  cygheap->heaptop = newtop;
   return oldbrk;
 }

winsup/cygwin/heap.h

@@ -15,10 +15,3 @@ void heap_init ();
 void malloc_init ();
 
 #define inheap(s) (brk && ((char *) (s) >= (char *) brkbase) && ((char *) (s) <= (char *) brktop))
-
-#define brksize ((char *) cygheap->heaptop - (char *) cygheap->heapbase)
-#define brk (cygheap->heapptr)
-#define brkbase (cygheap->heapbase)
-#define brktop (cygheap->heaptop)
-#define brkchunk (cygwin_shared->heap_chunk_size ())
-

winsup/cygwin/shared.cc

@@ -103,8 +103,6 @@ open_shared (const char *name, HANDLE &shared_h, DWORD size, void *addr)
 void
 shared_info::initialize ()
 {
-  /* Ya, Win32 provides a way for a dll to watch when it's first loaded.
-     We may eventually want to use it but for now we have this.  */
   if (inited)
     {
       if (inited != SHAREDVER)
@@ -120,23 +118,6 @@ shared_info::initialize ()
 
   /* Initialize tty table.  */
   tty.init ();
-
-  /* Fetch misc. registry entries.  */
-
-  reg_key reg (KEY_READ, NULL);
-
-  /* Note that reserving a huge amount of heap space does not result in
-  the use of swap since we are not committing it. */
-  /* FIXME: We should not be restricted to a fixed size heap no matter
-  what the fixed size is. */
-
-  heap_chunk_in_mb = reg.get_int ("heap_chunk_in_mb", 256);
-  if (heap_chunk_in_mb < 4)
-    {
-      heap_chunk_in_mb = 4;
-      reg.set_int ("heap_chunk_in_mb", heap_chunk_in_mb);
-    }
-
   inited = SHAREDVER;
 }
 
@@ -198,6 +179,25 @@ shared_terminate ()
 unsigned
 shared_info::heap_chunk_size ()
 {
+  if (!heap_chunk_in_mb)
+    {
+      /* Fetch misc. registry entries.  */
+
+      reg_key reg (KEY_READ, NULL);
+
+      /* Note that reserving a huge amount of heap space does not result in
+      the use of swap since we are not committing it. */
+      /* FIXME: We should not be restricted to a fixed size heap no matter
+      what the fixed size is. */
+
+      heap_chunk_in_mb = reg.get_int ("heap_chunk_in_mb", 256);
+      if (heap_chunk_in_mb < 4)
+	{
+	  heap_chunk_in_mb = 4;
+	  reg.set_int ("heap_chunk_in_mb", heap_chunk_in_mb);
+	}
+    }
+
   return heap_chunk_in_mb << 20;
 }
 

winsup/cygwin/shared_info.h

@@ -137,8 +137,8 @@ class shared_info
 
   tty_list tty;
   delqueue_list delqueue;
-  void initialize (void);
+  void initialize ();
-  unsigned heap_chunk_size (void);
+  unsigned heap_chunk_size ();
 };
 
 extern shared_info *cygwin_shared;

winsup/cygwin/smallprint.c

@@ -212,11 +212,15 @@ console_printf (const char *fmt,...)
   va_list ap;
   DWORD done;
   int count;
-  extern SECURITY_ATTRIBUTES sec_none;
 
   if (!console_handle)
-    console_handle = CreateFileA ("CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE,
+    console_handle = CreateFileA ("CON", GENERIC_WRITE,
-				  &sec_none, OPEN_EXISTING, 0, 0);
+				  FILE_SHARE_READ | FILE_SHARE_WRITE,
+				  NULL, OPEN_EXISTING, 0, 0);
+
+  if (console_handle == INVALID_HANDLE_VALUE)
+    console_handle = GetStdHandle (STD_ERROR_HANDLE);
+
   va_start (ap, fmt);
   count = __small_vsprintf (buf, fmt, ap);
   va_end (ap);