Add assertions that GC_page_size is initialized

* alloc.c (GC_expand_hp_inner): Assert that GC_page_size is non-zero.
* backgraph.c (new_back_edges, push_in_progress): Likewise.
* headers.c (GC_scratch_alloc): Likewise.
* mark.c (GC_wait_for_markers_init): Likewise.
* misc.c [GC_READ_ENV_FILE && (MSWIN32 || MSWINCE || CYGWIN32)]
(GC_envfile_init): Likewise.
* os_dep.c [!OS2 && GWW_VDB] (detect_GetWriteWatch): Likewise.
* os_dep.c [MSWIN32] (GC_least_described_address): Likewise.
* os_dep.c [MMAP_SUPPORTED && !MSWIN_XBOX1] (GC_unix_mmap_get_mem):
Likewise.
* os_dep.c [MMAP_SUPPORTED && !USE_MMAP] (GC_unix_sbrk_get_mem):
Likewise.
* os_dep.c [MSWINCE] (GC_wince_get_mem): Likewise.
* os_dep.c [USE_MUNMAP] (GC_unmap_start): Likewise.
* os_dep.c [!GC_DISABLE_INCREMENTAL && MPROTECT_VDB && !DARWIN]
(GC_write_fault_handler): Likewise.
* os_dep.c [!GC_DISABLE_INCREMENTAL && MPROTECT_VDB] (GC_protect_heap,
GC_remove_protection): Likewise.
* os_dep.c [!GC_DISABLE_INCREMENTAL && MPROTECT_VDB && DARWIN]
(catch_exception_raise): Likewise.

6 files changed, 23 insertions, 7 deletions

diff --git a/alloc.c b/alloc.c
index 0e2ec159..9e0ebaf7 100644
--- a/alloc.c
+++ b/alloc.c
@@ -1416,6 +1416,7 @@ GC_INNER GC_bool GC_expand_hp_inner(word n)
                                 /* heap to expand soon.                   */
 
     GC_ASSERT(I_HOLD_LOCK());
+    GC_ASSERT(GC_page_size != 0);
     if (n < MINHINCR) n = MINHINCR;
     bytes = ROUNDUP_PAGESIZE((size_t)n * HBLKSIZE);
     if (GC_max_heapsize != 0
diff --git a/backgraph.c b/backgraph.c
index d0d371fc..6c8f5660 100644
--- a/backgraph.c
+++ b/backgraph.c
@@ -90,6 +90,7 @@ static back_edges * new_back_edges(void)
     size_t bytes_to_get = ROUNDUP_PAGESIZE_IF_MMAP(MAX_BACK_EDGE_STRUCTS
                                                    * sizeof(back_edges));
 
+    GC_ASSERT(GC_page_size != 0);
     back_edge_space = (back_edges *)GET_MEM(bytes_to_get);
     if (NULL == back_edge_space)
       ABORT("Insufficient memory for back edges");
@@ -132,6 +133,7 @@ static void push_in_progress(ptr_t p)
   if (n_in_progress >= in_progress_size) {
     ptr_t * new_in_progress_space;
 
+    GC_ASSERT(GC_page_size != 0);
     if (NULL == in_progress_space) {
       in_progress_size = ROUNDUP_PAGESIZE_IF_MMAP(INITIAL_IN_PROGRESS
                                                         * sizeof(ptr_t))
diff --git a/headers.c b/headers.c
index 199ce85c..a1ab35a3 100644
--- a/headers.c
+++ b/headers.c
@@ -115,6 +115,7 @@ GC_INNER ptr_t GC_scratch_alloc(size_t bytes)
             return result;
         }
 
+        GC_ASSERT(GC_page_size != 0);
         if (bytes >= MINHINCR * HBLKSIZE) {
             bytes_to_get = ROUNDUP_PAGESIZE_IF_MMAP(bytes);
             result = (ptr_t)GET_MEM(bytes_to_get);
diff --git a/mark.c b/mark.c
index 71525fee..e63855f5 100644
--- a/mark.c
+++ b/mark.c
@@ -916,6 +916,8 @@ GC_INNER void GC_wait_for_markers_init(void)
   {
     size_t bytes_to_get =
                 ROUNDUP_PAGESIZE_IF_MMAP(LOCAL_MARK_STACK_SIZE * sizeof(mse));
+
+    GC_ASSERT(GC_page_size != 0);
     GC_main_local_mark_stack = (mse *)GET_MEM(bytes_to_get);
     if (NULL == GC_main_local_mark_stack)
       ABORT("Insufficient memory for main local_mark_stack");
diff --git a/misc.c b/misc.c
index db0e527c..b14293f8 100644
--- a/misc.c
+++ b/misc.c
@@ -686,6 +686,7 @@ GC_API void GC_CALL GC_get_heap_usage_safe(GC_word *pheap_size,
       }
       /* At this execution point, GC_setpagesize() and GC_init_win32()  */
       /* must already be called (for GET_MEM() to work correctly).      */
+      GC_ASSERT(GC_page_size != 0);
       content = (char *)GET_MEM(ROUNDUP_PAGESIZE_IF_MMAP((size_t)len + 1));
       if (content == NULL) {
         CloseHandle(hFile);
diff --git a/os_dep.c b/os_dep.c
index 151e1fd1..16ff4571 100644
--- a/os_dep.c
+++ b/os_dep.c
@@ -1691,9 +1691,11 @@ void GC_register_data_segments(void)
         /* Also check whether VirtualAlloc accepts MEM_WRITE_WATCH,   */
         /* as some versions of kernel32.dll have one but not the      */
         /* other, making the feature completely broken.               */
-        void * page = VirtualAlloc(NULL, GC_page_size,
-                                    MEM_WRITE_WATCH | MEM_RESERVE,
-                                    PAGE_READWRITE);
+        void * page;
+
+        GC_ASSERT(GC_page_size != 0);
+        page = VirtualAlloc(NULL, GC_page_size, MEM_WRITE_WATCH | MEM_RESERVE,
+                            PAGE_READWRITE);
         if (page != NULL) {
           PVOID pages[16];
           GC_ULONG_PTR count = 16;
@@ -1777,11 +1779,10 @@ void GC_register_data_segments(void)
   STATIC ptr_t GC_least_described_address(ptr_t start)
   {
     MEMORY_BASIC_INFORMATION buf;
-    LPVOID limit;
-    ptr_t p;
+    LPVOID limit = GC_sysinfo.lpMinimumApplicationAddress;
+    ptr_t p = (ptr_t)((word)start & ~(GC_page_size - 1));
 
-    limit = GC_sysinfo.lpMinimumApplicationAddress;
-    p = (ptr_t)((word)start & ~(GC_page_size - 1));
+    GC_ASSERT(GC_page_size != 0);
     for (;;) {
         size_t result;
         LPVOID q = (LPVOID)(p - GC_page_size);
@@ -2200,6 +2201,7 @@ void GC_register_data_segments(void)
       }
 #   endif
 
+    GC_ASSERT(GC_page_size != 0);
     if (bytes & (GC_page_size - 1)) ABORT("Bad GET_MEM arg");
     result = mmap(last_addr, bytes, (PROT_READ | PROT_WRITE)
                                     | (GC_pages_executable ? PROT_EXEC : 0),
@@ -2253,6 +2255,7 @@ STATIC ptr_t GC_unix_sbrk_get_mem(size_t bytes)
     ptr_t cur_brk = (ptr_t)sbrk(0);
     SBRK_ARG_T lsbs = (word)cur_brk & (GC_page_size-1);
 
+    GC_ASSERT(GC_page_size != 0);
     if ((SBRK_ARG_T)bytes < 0) {
         result = 0; /* too big */
         goto out;
@@ -2345,6 +2348,7 @@ void * os2_alloc(size_t bytes)
     ptr_t result = 0; /* initialized to prevent warning. */
     word i;
 
+    GC_ASSERT(GC_page_size != 0);
     bytes = ROUNDUP_PAGESIZE(bytes);
 
     /* Try to find reserved, uncommitted pages */
@@ -2557,6 +2561,7 @@ STATIC ptr_t GC_unmap_start(ptr_t start, size_t bytes)
     ptr_t result = (ptr_t)(((word)start + GC_page_size - 1)
                             & ~(GC_page_size - 1));
 
+    GC_ASSERT(GC_page_size != 0);
     if ((word)(result + GC_page_size) > (word)(start + bytes)) return 0;
     return result;
 }
@@ -3224,6 +3229,7 @@ GC_API GC_push_other_roots_proc GC_CALL GC_get_push_other_roots(void)
         GC_bool in_allocd_block;
         size_t i;
 
+        GC_ASSERT(GC_page_size != 0);
 #       ifdef CHECKSUMS
           GC_record_fault(h);
 #       endif
@@ -3442,6 +3448,7 @@ STATIC void GC_protect_heap(void)
     GC_bool protect_all =
         (0 != (GC_incremental_protection_needs() & GC_PROTECTS_PTRFREE_HEAP));
 
+    GC_ASSERT(GC_page_size != 0);
     for (i = 0; i < GC_n_heap_sects; i++) {
         ptr_t start = GC_heap_sects[i].hs_start;
         size_t len = GC_heap_sects[i].hs_bytes;
@@ -3814,6 +3821,7 @@ GC_INNER GC_bool GC_dirty_init(void)
 
       if (!GC_auto_incremental || GC_GWW_AVAILABLE())
         return;
+      GC_ASSERT(GC_page_size != 0);
       h_trunc = (struct hblk *)((word)h & ~(GC_page_size-1));
       h_end = (struct hblk *)(((word)(h + nblocks) + GC_page_size - 1)
                               & ~(GC_page_size - 1));
@@ -4441,6 +4449,7 @@ catch_exception_raise(mach_port_t exception_port GC_ATTR_UNUSED,
     GC_sigbus_count = 0;
 # endif
 
+  GC_ASSERT(GC_page_size != 0);
   if (GC_mprotect_state == GC_MP_NORMAL) { /* common case */
     struct hblk * h = (struct hblk*)((word)addr & ~(GC_page_size-1));
     size_t i;