Move to size_t in allocations.

15 files changed, 265 insertions, 224 deletions

diff --git a/base/gsalloc.c b/base/gsalloc.c
index f40e85a0e..89fb91e7c 100644
--- a/base/gsalloc.c
+++ b/base/gsalloc.c
@@ -62,7 +62,7 @@ gs_id get_mem_hdr_id (void *ptr)
 static int
 alloc_trace_space(const gs_ref_memory_t *imem)
 {
-    return imem->space + (imem->stable_memory == (const gs_memory_t *)imem);
+    return (int)(imem->space + (imem->stable_memory == (const gs_memory_t *)imem));
 }
 static void
 alloc_trace(const char *chars, gs_ref_memory_t * imem, client_name_t cname,
@@ -125,14 +125,14 @@ typedef enum {
 
 /* Forward references */
 static void remove_range_from_freelist(gs_ref_memory_t *mem, void* bottom, void* top);
-static obj_header_t *large_freelist_alloc(gs_ref_memory_t *mem, uint size);
+static obj_header_t *large_freelist_alloc(gs_ref_memory_t *mem, obj_size_t size);
 static obj_header_t *scavenge_low_free(gs_ref_memory_t *mem, unsigned request_size);
-static ulong compute_free_objects(gs_ref_memory_t *);
-static obj_header_t *alloc_obj(gs_ref_memory_t *, ulong, gs_memory_type_ptr_t, alloc_flags_t, client_name_t);
+static size_t compute_free_objects(gs_ref_memory_t *);
+static obj_header_t *alloc_obj(gs_ref_memory_t *, obj_size_t, gs_memory_type_ptr_t, alloc_flags_t, client_name_t);
 static void consolidate_clump_free(clump_t *cp, gs_ref_memory_t *mem);
-static void trim_obj(gs_ref_memory_t *mem, obj_header_t *obj, uint size, clump_t *cp);
-static clump_t *alloc_acquire_clump(gs_ref_memory_t *, ulong, bool, client_name_t);
-static clump_t *alloc_add_clump(gs_ref_memory_t *, ulong, client_name_t);
+static void trim_obj(gs_ref_memory_t *mem, obj_header_t *obj, obj_size_t size, clump_t *cp);
+static clump_t *alloc_acquire_clump(gs_ref_memory_t *, size_t, bool, client_name_t);
+static clump_t *alloc_add_clump(gs_ref_memory_t *, size_t, client_name_t);
 void alloc_close_clump(gs_ref_memory_t *);
 
 /*
@@ -1043,7 +1043,7 @@ i_free_all(gs_memory_t * mem, uint free_mask, client_name_t cname)
 /* ================ Accessors ================ */
 
 /* Get the size of an object from the header. */
-static uint
+static size_t
 i_object_size(gs_memory_t * mem, const void /*obj_header_t */ *obj)
 {
     return pre_obj_contents_size((const obj_header_t *)obj - 1);
@@ -1073,7 +1073,7 @@ gs_memory_set_gc_status(gs_ref_memory_t * mem, const gs_memory_gc_status_t * pst
 
 /* Set VM threshold. */
 void
-gs_memory_set_vm_threshold(gs_ref_memory_t * mem, long val)
+gs_memory_set_vm_threshold(gs_ref_memory_t * mem, size_t val)
 {
     gs_memory_gc_status_t stat;
     gs_ref_memory_t * stable = (gs_ref_memory_t *)mem->stable_memory;
@@ -1113,7 +1113,7 @@ gs_memory_set_vm_reclaim(gs_ref_memory_t * mem, bool enabled)
            )\
         {	ptr = *pfl;\
                 *pfl = *(obj_header_t **)ptr;\
-                ptr[-1].o_size = size;\
+                ptr[-1].o_size = (obj_size_t)size;\
                 ptr[-1].o_type = pstype;\
                 ASSIGN_HDR_ID(ptr);\
                 /* If debugging, clear the block in an attempt to */\
@@ -1138,7 +1138,7 @@ gs_memory_set_vm_reclaim(gs_ref_memory_t * mem, bool enabled)
         {	imem->cc->cbot = (byte *)ptr + obj_size_round(size);\
                 ptr->o_pad = 0;\
                 ptr->o_alone = 0;\
-                ptr->o_size = size;\
+                ptr->o_size = (obj_size_t)size;\
                 ptr->o_type = pstype;\
                 ptr++;\
                 ASSIGN_HDR_ID(ptr);\
@@ -1150,22 +1150,26 @@ gs_memory_set_vm_reclaim(gs_ref_memory_t * mem, bool enabled)
         else
 
 static byte *
-i_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
+i_alloc_bytes(gs_memory_t * mem, size_t ssize, client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
     obj_header_t *obj;
     obj_header_t **pfl;
+    obj_size_t size = (obj_size_t)ssize;
 
 #ifdef MEMENTO
     if (Memento_failThisEvent())
         return NULL;
 #endif
 
+    if ((size_t)size != ssize)
+        return NULL;
+
     IF_FREELIST_ALLOC(obj, imem, size, &st_bytes, pfl)
         alloc_trace(":+bf", imem, cname, NULL, size, obj);
     ELSEIF_BIG_FREELIST_ALLOC(obj, imem, size, &st_bytes)
         alloc_trace(":+bF", imem, cname, NULL, size, obj);
-    ELSEIF_LIFO_ALLOC(obj, imem, size, &st_bytes)
+    ELSEIF_LIFO_ALLOC(obj, imem, (uint)size, &st_bytes)
         alloc_trace(":+b ", imem, cname, NULL, size, obj);
     ELSE_ALLOC
     {
@@ -1180,16 +1184,20 @@ i_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
     return (byte *) obj;
 }
 static byte *
-i_alloc_bytes_immovable(gs_memory_t * mem, uint size, client_name_t cname)
+i_alloc_bytes_immovable(gs_memory_t * mem, size_t ssize, client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
     obj_header_t *obj;
+    obj_size_t size = (obj_size_t)ssize;
 
 #ifdef MEMENTO
     if (Memento_failThisEvent())
         return NULL;
 #endif
 
+    if ((size_t)size != ssize)
+        return NULL;
+
     obj = alloc_obj(imem, size, &st_bytes,
                     ALLOC_IMMOVABLE | ALLOC_DIRECT, cname);
     if (obj == 0)
@@ -1202,7 +1210,7 @@ i_alloc_struct(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
                client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
-    uint size = pstype->ssize;
+    obj_size_t size = pstype->ssize;
     obj_header_t *obj;
     obj_header_t **pfl;
 
@@ -1235,7 +1243,7 @@ i_alloc_struct_immovable(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
                          client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
-    uint size = pstype->ssize;
+    obj_size_t size = pstype->ssize;
     obj_header_t *obj;
 
 #ifdef MEMENTO
@@ -1250,68 +1258,89 @@ i_alloc_struct_immovable(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
 }
 
 static inline bool
-alloc_array_check_size(ulong num_elements, ulong elt_size, ulong *lsize)
+alloc_array_check_size(size_t num_elements, size_t elt_size, size_t *lsize)
 {
-    int64_t s = (int64_t)num_elements * elt_size;
-    if (s > max_uint) {
-        return false;
+    int shift0, shift1;
+    size_t m, n;
+
+    /* Avoid the loops in the overwhelming number of cases. */
+    if ((num_elements | elt_size) >= 65536) {
+        /* Slightly conservative, but it'll work for our purposes. */
+        /* m is the maximum unsigned value representable in shift0 bits */
+        for (m=0, shift0 = 0; m < num_elements; m = (m<<1)+1, shift0++);
+        /* n is the maximum unsigned value representable in shift1 bits */
+        for (n=0, shift1 = 0; n < elt_size; n = (n<<1)+1, shift1++);
+        /* An shift0 bit unsigned number multiplied by an shift1 bit
+         * unsigned number is guaranteed to fit in n+m-1 bits. */
+        if (shift0+shift1-1 > 8*sizeof(size_t))
+            return false; /* Overflow */
     }
-    *lsize = (ulong)s;
+
+    *lsize = num_elements * elt_size;
     return true;
 }
 
 static byte *
-i_alloc_byte_array(gs_memory_t * mem, uint num_elements, uint elt_size,
+i_alloc_byte_array(gs_memory_t * mem, size_t num_elements, size_t elt_size,
                    client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
     obj_header_t *obj;
-    ulong lsize;
+    size_t slsize;
+    obj_size_t lsize;
 #ifdef MEMENTO
     if (Memento_failThisEvent())
         return NULL;
 #endif
-    if (alloc_array_check_size(num_elements, elt_size, &lsize) == false)
+    if (alloc_array_check_size(num_elements, elt_size, &slsize) == false)
+        return NULL;
+    lsize = (obj_size_t)slsize;
+    if ((size_t)lsize != slsize)
         return NULL;
     obj = alloc_obj(imem, lsize,
                     &st_bytes, ALLOC_DIRECT, cname);
 
-    if_debug6m('A', mem, "[a%d:+b.]%s -bytes-*(%lu=%u*%u) = 0x%lx\n",
+    if_debug6m('A', mem, "[a%d:+b.]%s -bytes-*(%"PRIuSIZE"=%"PRIuSIZE"*%"PRIuSIZE") = 0x%lx\n",
                alloc_trace_space(imem), client_name_string(cname),
-               (ulong) num_elements * elt_size,
+               num_elements * elt_size,
                num_elements, elt_size, (ulong) obj);
     return (byte *) obj;
 }
 static byte *
-i_alloc_byte_array_immovable(gs_memory_t * mem, uint num_elements,
-                             uint elt_size, client_name_t cname)
+i_alloc_byte_array_immovable(gs_memory_t * mem, size_t num_elements,
+                             size_t elt_size, client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
     obj_header_t *obj;
-    ulong lsize;
+    size_t slsize;
+    obj_size_t lsize;
 #ifdef MEMENTO
     if (Memento_failThisEvent())
         return NULL;
 #endif
-    if (alloc_array_check_size(num_elements, elt_size, &lsize) == false)
+    if (alloc_array_check_size(num_elements, elt_size, &slsize) == false)
+        return NULL;
+    lsize = (obj_size_t)slsize;
+    if ((size_t)lsize != slsize)
         return NULL;
     obj = alloc_obj(imem, lsize,
                     &st_bytes, ALLOC_IMMOVABLE | ALLOC_DIRECT,
                     cname);
 
-    if_debug6m('A', mem, "[a%d|+b.]%s -bytes-*(%lu=%u*%u) = 0x%lx\n",
+    if_debug6m('A', mem, "[a%d|+b.]%s -bytes-*(%"PRIuSIZE"=%"PRIuSIZE"*%"PRIuSIZE") = 0x%lx\n",
                alloc_trace_space(imem), client_name_string(cname),
-               (ulong) num_elements * elt_size,
+               num_elements * elt_size,
                num_elements, elt_size, (ulong) obj);
     return (byte *) obj;
 }
 static void *
-i_alloc_struct_array(gs_memory_t * mem, uint num_elements,
+i_alloc_struct_array(gs_memory_t * mem, size_t num_elements,
                      gs_memory_type_ptr_t pstype, client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
     obj_header_t *obj;
-    ulong lsize;
+    size_t slsize;
+    obj_size_t lsize;
 #ifdef MEMENTO
     if (Memento_failThisEvent())
         return NULL;
@@ -1325,50 +1354,57 @@ i_alloc_struct_array(gs_memory_t * mem, uint num_elements,
         return NULL;		/* fail */
     }
 #endif
-    if (alloc_array_check_size(num_elements, pstype->ssize, &lsize) == false)
+    if (alloc_array_check_size(num_elements, pstype->ssize, &slsize) == false)
+        return NULL;
+    lsize = (obj_size_t)slsize;
+    if ((size_t)lsize != slsize)
         return NULL;
     obj = alloc_obj(imem, lsize, pstype, ALLOC_DIRECT, cname);
-    if_debug7m('A', mem, "[a%d:+<.]%s %s*(%lu=%u*%u) = 0x%lx\n",
+    if_debug7m('A', mem, "[a%d:+<.]%s %s*(%"PRIuSIZE"=%"PRIuSIZE"*%u) = 0x%lx\n",
                alloc_trace_space(imem), client_name_string(cname),
                struct_type_name_string(pstype),
-               (ulong) num_elements * pstype->ssize,
+               num_elements * pstype->ssize,
                num_elements, pstype->ssize, (ulong) obj);
     return (char *)obj;
 }
 static void *
-i_alloc_struct_array_immovable(gs_memory_t * mem, uint num_elements,
-                           gs_memory_type_ptr_t pstype, client_name_t cname)
+i_alloc_struct_array_immovable(gs_memory_t * mem, size_t num_elements,
+                               gs_memory_type_ptr_t pstype, client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
     obj_header_t *obj;
-    ulong lsize;
+    size_t slsize;
+    obj_size_t lsize;
 #ifdef MEMENTO
     if (Memento_failThisEvent())
         return NULL;
 #endif
 
     ALLOC_CHECK_SIZE(mem,pstype);
-    if (alloc_array_check_size(num_elements, pstype->ssize, &lsize) == false)
+    if (alloc_array_check_size(num_elements, pstype->ssize, &slsize) == false)
+        return NULL;
+    lsize = (obj_size_t)slsize;
+    if ((size_t)lsize != slsize)
         return NULL;
     obj = alloc_obj(imem, lsize, pstype, ALLOC_IMMOVABLE | ALLOC_DIRECT, cname);
-    if_debug7m('A', mem, "[a%d|+<.]%s %s*(%lu=%u*%u) = 0x%lx\n",
+    if_debug7m('A', mem, "[a%d|+<.]%s %s*(%"PRIuSIZE"=%"PRIuSIZE"*%u) = 0x%lx\n",
                alloc_trace_space(imem), client_name_string(cname),
                struct_type_name_string(pstype),
-               (ulong) num_elements * pstype->ssize,
+               num_elements * pstype->ssize,
                num_elements, pstype->ssize, (ulong) obj);
     return (char *)obj;
 }
 static void *
-i_resize_object(gs_memory_t * mem, void *obj, uint new_num_elements,
+i_resize_object(gs_memory_t * mem, void *obj, size_t new_num_elements,
                 client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
     obj_header_t *pp = (obj_header_t *) obj - 1;
     gs_memory_type_ptr_t pstype = pp->o_type;
-    ulong old_size = pre_obj_contents_size(pp);
-    ulong new_size = (ulong) pstype->ssize * new_num_elements;
-    ulong old_size_rounded = obj_align_round(old_size);
-    ulong new_size_rounded = obj_align_round(new_size);
+    size_t old_size = pre_obj_contents_size(pp);
+    size_t new_size = pstype->ssize * new_num_elements;
+    size_t old_size_rounded = obj_align_round(old_size);
+    size_t new_size_rounded = obj_align_round(new_size);
     void *new_obj = NULL;
 
 #ifdef MEMENTO
@@ -1376,22 +1412,25 @@ i_resize_object(gs_memory_t * mem, void *obj, uint new_num_elements,
         return NULL;
 #endif
 
+    if (new_size_rounded != (obj_size_t)new_size_rounded)
+        return NULL;
+
     if (old_size_rounded == new_size_rounded) {
-        pp->o_size = new_size;
+        pp->o_size = (obj_size_t)new_size;
         new_obj = obj;
     } else
         if (imem->cc && (byte *)obj + old_size_rounded == imem->cc->cbot &&
             imem->cc->ctop - (byte *)obj >= new_size_rounded ) {
             imem->cc->cbot = (byte *)obj + new_size_rounded;
-            pp->o_size = new_size;
+            pp->o_size = (obj_size_t)new_size;
             new_obj = obj;
         } else /* try and trim the object -- but only if room for a dummy header */
             if (new_size_rounded + sizeof(obj_header_t) <= old_size_rounded) {
-                trim_obj(imem, obj, new_size, (clump_t *)0);
+                trim_obj(imem, obj, (obj_size_t)new_size, (clump_t *)0);
                 new_obj = obj;
             }
     if (new_obj) {
-        if_debug8m('A', mem, "[a%d:%c%c ]%s %s(%lu=>%lu) 0x%lx\n",
+        if_debug8m('A', mem, "[a%d:%c%c ]%s %s(%"PRIuSIZE"=>%"PRIuSIZE") 0x%lx\n",
                    alloc_trace_space(imem),
                    (new_size > old_size ? '>' : '<'),
                    (pstype == &st_bytes ? 'b' : '<'),
@@ -1418,7 +1457,7 @@ i_free_object(gs_memory_t * mem, void *ptr, client_name_t cname)
     gs_memory_struct_type_t saved_stype;
 
     struct_proc_finalize((*finalize));
-    uint size, rounded_size;
+    size_t size, rounded_size;
 
     if (ptr == 0)
         return;
@@ -1570,7 +1609,7 @@ i_free_object(gs_memory_t * mem, void *ptr, client_name_t cname)
     imem->lost.objects += obj_size_round(size);
 }
 static byte *
-i_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
+i_alloc_string(gs_memory_t * mem, size_t nbytes, client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
     byte *str;
@@ -1582,7 +1621,7 @@ i_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
      */
     clump_t *cp = clump_splay_walk_init_mid(&sw, imem->cc);
 
-    if (nbytes + (uint)HDR_ID_OFFSET < nbytes)
+    if (nbytes + (size_t)HDR_ID_OFFSET < nbytes)
         return NULL;
 
     nbytes += HDR_ID_OFFSET;
@@ -1598,7 +1637,7 @@ i_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
     }
 top:
     if (imem->cc && !imem->cc->c_alone && imem->cc->ctop - imem->cc->cbot > nbytes) {
-        if_debug4m('A', mem, "[a%d:+> ]%s(%u) = 0x%lx\n",
+        if_debug4m('A', mem, "[a%d:+> ]%s(%"PRIuSIZE") = 0x%lx\n",
                    alloc_trace_space(imem), client_name_string(cname), nbytes,
                    (ulong) (imem->cc->ctop - nbytes));
         str = imem->cc->ctop -= nbytes;
@@ -1617,7 +1656,7 @@ top:
         alloc_open_clump(imem);
         goto top;
     }
-    if (nbytes > string_space_quanta(max_uint - sizeof(clump_head_t)) *
+    if (nbytes > string_space_quanta(SIZE_MAX - sizeof(clump_head_t)) *
         string_data_quantum
         ) {			/* Can't represent the size in a uint! */
         return 0;
@@ -1637,11 +1676,11 @@ top:
     }
 }
 static byte *
-i_alloc_string_immovable(gs_memory_t * mem, uint nbytes, client_name_t cname)
+i_alloc_string_immovable(gs_memory_t * mem, size_t nbytes, client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
     byte *str;
-    uint asize;
+    size_t asize;
     clump_t *cp;
 
     nbytes += HDR_ID_OFFSET;
@@ -1652,15 +1691,14 @@ i_alloc_string_immovable(gs_memory_t * mem, uint nbytes, client_name_t cname)
 #endif
     /* Give it a clump all its own. */
     asize = string_clump_space(nbytes) + sizeof(clump_head_t);
-    cp = alloc_acquire_clump(imem, (ulong) asize, true,
-                                      "large string clump");
+    cp = alloc_acquire_clump(imem, asize, true, "large string clump");
 
     if (cp == 0)
         return 0;
     cp->c_alone = true;
 
     str = cp->ctop = cp->climit - nbytes;
-    if_debug4m('a', mem, "[a%d|+>L]%s(%u) = 0x%lx\n",
+    if_debug4m('a', mem, "[a%d|+>L]%s(%"PRIuSIZE") = 0x%lx\n",
                alloc_trace_space(imem), client_name_string(cname), nbytes,
                (ulong) str);
     gs_alloc_fill(str, gs_alloc_fill_alloc, nbytes);
@@ -1671,7 +1709,7 @@ i_alloc_string_immovable(gs_memory_t * mem, uint nbytes, client_name_t cname)
 }
 
 static byte *
-i_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num,
+i_resize_string(gs_memory_t * mem, byte * data, size_t old_num, size_t new_num,
                 client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
@@ -1689,7 +1727,7 @@ i_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num,
          imem->cc->ctop - imem->cc->cbot > new_num - old_num)
         ) {			/* Resize in place. */
         ptr = data + old_num - new_num;
-        if_debug6m('A', mem, "[a%d:%c> ]%s(%u->%u) 0x%lx\n",
+        if_debug6m('A', mem, "[a%d:%c> ]%s(%"PRIuSIZE"->%"PRIuSIZE") 0x%lx\n",
                    alloc_trace_space(imem),
                    (new_num > old_num ? '>' : '<'),
                    client_name_string(cname), old_num, new_num,
@@ -1712,7 +1750,7 @@ i_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num,
             imem->lost.strings += old_num - new_num;
             gs_alloc_fill(data + new_num, gs_alloc_fill_free,
                           old_num - new_num);
-            if_debug5m('A', mem, "[a%d:<> ]%s(%u->%u) 0x%lx\n",
+            if_debug5m('A', mem, "[a%d:<> ]%s(%"PRIuSIZE"->%"PRIuSIZE") 0x%lx\n",
                        alloc_trace_space(imem), client_name_string(cname),
                        old_num, new_num, (ulong)ptr);
             ptr += HDR_ID_OFFSET;
@@ -1733,7 +1771,7 @@ i_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num,
 }
 
 static void
-i_free_string(gs_memory_t * mem, byte * data, uint nbytes,
+i_free_string(gs_memory_t * mem, byte * data, size_t nbytes,
               client_name_t cname)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
@@ -1742,12 +1780,12 @@ i_free_string(gs_memory_t * mem, byte * data, uint nbytes,
         data -= HDR_ID_OFFSET;
         nbytes += HDR_ID_OFFSET;
         if (imem->cc && data == imem->cc->ctop) {
-            if_debug4m('A', mem, "[a%d:-> ]%s(%u) 0x%lx\n",
+            if_debug4m('A', mem, "[a%d:-> ]%s(%"PRIuSIZE") 0x%lx\n",
                        alloc_trace_space(imem), client_name_string(cname), nbytes,
                        (ulong) data);
             imem->cc->ctop += nbytes;
         } else {
-            if_debug4m('A', mem, "[a%d:->#]%s(%u) 0x%lx\n",
+            if_debug4m('A', mem, "[a%d:->#]%s(%"PRIuSIZE") 0x%lx\n",
                        alloc_trace_space(imem), client_name_string(cname), nbytes,
                        (ulong) data);
             imem->lost.strings += nbytes;
@@ -1766,8 +1804,8 @@ static void
 i_status(gs_memory_t * mem, gs_memory_status_t * pstat)
 {
     gs_ref_memory_t * const imem = (gs_ref_memory_t *)mem;
-    ulong unused = imem->lost.refs + imem->lost.strings;
-    ulong inner = 0;
+    size_t unused = imem->lost.refs + imem->lost.strings;
+    size_t inner = 0;
     clump_splay_walker sw;
     clump_t *cp;
 
@@ -1818,10 +1856,10 @@ static void i_defer_frees(gs_memory_t *mem, int defer)
 /* ------ Internal procedures ------ */
 
 /* Compute the amount of free object space by scanning free lists. */
-static ulong
+static size_t
 compute_free_objects(gs_ref_memory_t * mem)
 {
-    ulong unused = mem->lost.objects;
+    size_t unused = mem->lost.objects;
     int i;
 
     /* Add up space on free lists. */
@@ -1838,26 +1876,26 @@ compute_free_objects(gs_ref_memory_t * mem)
 
 /* Allocate an object from the large-block freelist. */
 static obj_header_t *	/* rets obj if allocated, else 0 */
-large_freelist_alloc(gs_ref_memory_t *mem, uint size)
+large_freelist_alloc(gs_ref_memory_t *mem, obj_size_t size)
 {
     /* Scan large object freelist. We'll grab an object up to 1/8 bigger */
     /* right away, else use best fit of entire scan. */
-    uint aligned_size = obj_align_round(size);
-    uint aligned_min_size = aligned_size + sizeof(obj_header_t);
-    uint aligned_max_size =
+    obj_size_t aligned_size = obj_align_round(size);
+    size_t aligned_min_size = aligned_size + sizeof(obj_header_t);
+    size_t aligned_max_size =
         aligned_min_size + obj_align_round(aligned_min_size / 8);
     obj_header_t *best_fit = 0;
-    obj_header_t **best_fit_prev = NULL; /* Initialize against indeteminizm. */
-    uint best_fit_size = max_uint;
+    obj_header_t **best_fit_prev = NULL; /* Initialize against indeterminism. */
+    obj_size_t best_fit_size = (obj_size_t)SIZE_MAX;
     obj_header_t *pfree;
     obj_header_t **ppfprev = &mem->freelists[LARGE_FREELIST_INDEX];
-    uint largest_size = 0;
+    size_t largest_size = 0;
 
     if (aligned_size > mem->largest_free_size)
         return 0;		/* definitely no block large enough */
 
     while ((pfree = *ppfprev) != 0) {
-        uint free_size = obj_align_round(pfree[-1].o_size);
+        obj_size_t free_size = obj_align_round(pfree[-1].o_size);
 
         if (free_size == aligned_size ||
             (free_size >= aligned_min_size && free_size < best_fit_size)
@@ -1894,7 +1932,7 @@ large_freelist_alloc(gs_ref_memory_t *mem, uint size)
 
 /* Allocate an object.  This handles all but the fastest, simplest case. */
 static obj_header_t *
-alloc_obj(gs_ref_memory_t *mem, ulong lsize, gs_memory_type_ptr_t pstype,
+alloc_obj(gs_ref_memory_t *mem, obj_size_t lsize, gs_memory_type_ptr_t pstype,
           alloc_flags_t flags, client_name_t cname)
 {
     obj_header_t *ptr;
@@ -1904,20 +1942,14 @@ alloc_obj(gs_ref_memory_t *mem, ulong lsize, gs_memory_type_ptr_t pstype,
          * Give the object a clump all its own.  Note that this case does
          * not occur if is_controlled is true.
          */
-        ulong asize =
+        obj_size_t asize =
             ((lsize + obj_align_mask) & -obj_align_mod) +
             sizeof(obj_header_t);
         clump_t *cp =
             alloc_acquire_clump(mem, asize + sizeof(clump_head_t), false,
                                 "large object clump");
 
-        if (
-#if ARCH_SIZEOF_LONG > ARCH_SIZEOF_INT
-            asize > max_uint
-#else
-            asize < lsize
-#endif
-            )
+        if (asize < lsize)
             return 0;
         if (cp == 0)
             return 0;
@@ -1926,7 +1958,7 @@ alloc_obj(gs_ref_memory_t *mem, ulong lsize, gs_memory_type_ptr_t pstype,
         cp->cbot += asize;
         ptr->o_pad = 0;
         ptr->o_alone = 1;
-        ptr->o_size = lsize;
+        ptr->o_size = (obj_size_t)lsize;
     } else {
         /*
          * Cycle through the clumps at the current save level, starting
@@ -1934,7 +1966,7 @@ alloc_obj(gs_ref_memory_t *mem, ulong lsize, gs_memory_type_ptr_t pstype,
          */
         clump_splay_walker sw;
         clump_t *cp = clump_splay_walk_init_mid(&sw, mem->cc);
-        uint asize = obj_size_round((uint) lsize);
+        obj_size_t asize = obj_size_round(lsize);
         bool allocate_success = false;
 
         if (lsize > max_freelist_size && (flags & ALLOC_DIRECT)) {
@@ -2008,7 +2040,7 @@ alloc_obj(gs_ref_memory_t *mem, ulong lsize, gs_memory_type_ptr_t pstype,
         if (!allocate_success) {
             /* Add another clump. */
             clump_t *cp =
-                alloc_add_clump(mem, (ulong)mem->clump_size, "clump");
+                alloc_add_clump(mem, mem->clump_size, "clump");
 
             if (cp) {
                 /* mem->cc == cp */
@@ -2026,11 +2058,11 @@ alloc_obj(gs_ref_memory_t *mem, ulong lsize, gs_memory_type_ptr_t pstype,
         if (allocate_success)
             mem->cc->cbot = (byte *) ptr + asize;
         else if (!mem->is_controlled ||
-                 (ptr = scavenge_low_free(mem, (uint)lsize)) == 0)
+                 (ptr = scavenge_low_free(mem, lsize)) == 0)
             return 0;	/* allocation failed */
         ptr->o_pad = 0;
         ptr->o_alone = 0;
-        ptr->o_size = (uint) lsize;
+        ptr->o_size = lsize;
     }
 done:
     ptr->o_type = pstype;
@@ -2125,7 +2157,7 @@ typedef struct
     uint need_free;
     obj_header_t *found_pre;
     gs_ref_memory_t *mem;
-    unsigned request_size;
+    obj_size_t request_size;
 } scavenge_data;
 
 static splay_app_result_t
@@ -2133,7 +2165,7 @@ scavenge(clump_t *cp, void *arg)
 {
     scavenge_data *sd = (scavenge_data *)arg;
     obj_header_t *begin_free = NULL;
-    uint found_free = 0;
+    obj_size_t found_free = 0;
 
     sd->found_pre = NULL;
 
@@ -2171,11 +2203,11 @@ scavenge(clump_t *cp, void *arg)
 
 /* try to free-up given amount of space from freespace below clump base */
 static obj_header_t *	/* returns uninitialized object hdr, NULL if none found */
-scavenge_low_free(gs_ref_memory_t *mem, unsigned request_size)
+scavenge_low_free(gs_ref_memory_t *mem, obj_size_t request_size)
 {
     /* find 1st range of memory that can be glued back together to fill request */
     scavenge_data sd;
-    uint request_size_rounded = obj_size_round(request_size);
+    obj_size_t request_size_rounded = obj_size_round(request_size);
 
     sd.found_pre = 0;
     sd.need_free = request_size_rounded + sizeof(obj_header_t);    /* room for GC's dummy hdr */
@@ -2193,9 +2225,9 @@ remove_range_from_freelist(gs_ref_memory_t *mem, void* bottom, void* top)
     int num_free[num_freelists];
     int smallest = num_freelists, largest = -1;
     const obj_header_t *cur;
-    uint size;
+    obj_size_t size;
     int i;
-    uint removed = 0;
+    obj_size_t removed = 0;
 
     /*
      * Scan from bottom to top, a range containing only free objects,
@@ -2261,15 +2293,15 @@ remove_range_from_freelist(gs_ref_memory_t *mem, void* bottom, void* top)
 
 /* Trim a memory object down to a given size */
 static void
-trim_obj(gs_ref_memory_t *mem, obj_header_t *obj, uint size, clump_t *cp)
+trim_obj(gs_ref_memory_t *mem, obj_header_t *obj, obj_size_t size, clump_t *cp)
 /* Obj must have rounded size == req'd size, or have enough room for */
 /* trailing dummy obj_header */
 {
-    uint rounded_size = obj_align_round(size);
+    obj_size_t rounded_size = obj_align_round(size);
     obj_header_t *pre_obj = obj - 1;
     obj_header_t *excess_pre = (obj_header_t*)((char*)obj + rounded_size);
-    uint old_rounded_size = obj_align_round(pre_obj->o_size);
-    uint excess_size = old_rounded_size - rounded_size - sizeof(obj_header_t);
+    obj_size_t old_rounded_size = obj_align_round(pre_obj->o_size);
+    obj_size_t excess_size = old_rounded_size - rounded_size - sizeof(obj_header_t);
 
     /* trim object's size to desired */
     pre_obj->o_size = size;
@@ -2398,7 +2430,7 @@ alloc_link_clump(clump_t * cp, gs_ref_memory_t * imem)
 
 /* Add a clump for ordinary allocation. */
 static clump_t *
-alloc_add_clump(gs_ref_memory_t * mem, ulong csize, client_name_t cname)
+alloc_add_clump(gs_ref_memory_t * mem, size_t csize, client_name_t cname)
 {
     clump_t *cp = alloc_acquire_clump(mem, csize, true, cname);
 
@@ -2416,7 +2448,7 @@ alloc_add_clump(gs_ref_memory_t * mem, ulong csize, client_name_t cname)
 /* return 0; if we would exceed the VMThreshold but psignal is valid, */
 /* just set the signal and return successfully. */
 static clump_t *
-alloc_acquire_clump(gs_ref_memory_t * mem, ulong csize, bool has_strings,
+alloc_acquire_clump(gs_ref_memory_t * mem, size_t csize, bool has_strings,
                     client_name_t cname)
 {
     gs_memory_t *parent = mem->non_gc_memory;
@@ -2437,7 +2469,7 @@ alloc_acquire_clump(gs_ref_memory_t * mem, ulong csize, bool has_strings,
      */
     if( mem->gc_status.signal_value != 0) {
         /* we have a garbage collector */
-        if ((ulong) (mem->allocated) >= mem->limit) {
+        if (mem->allocated >= mem->limit) {
             mem->gc_status.requested += csize;
             if (mem->limit >= mem->gc_status.max_vm) {
                 gs_free_object(parent, cp, cname);
diff --git a/base/gsalloc.h b/base/gsalloc.h
index 98772ce6e..7112b0470 100644
--- a/base/gsalloc.h
+++ b/base/gsalloc.h
@@ -28,17 +28,17 @@ typedef struct gs_ref_memory_s gs_ref_memory_t;
  */
 typedef struct gs_memory_gc_status_s {
         /* Set by client */
-    long vm_threshold;		/* GC interval */
-    long max_vm;		/* maximum allowed allocation */
+    size_t vm_threshold;		/* GC interval */
+    size_t max_vm;		/* maximum allowed allocation */
 
     int signal_value;		/* value to store in gs_lib_ctx->gcsignal */
     bool enabled;		/* auto GC enabled if true */
         /* Set by allocator */
-    long requested;		/* amount of last failing request */
+    size_t requested;		/* amount of last failing request */
 } gs_memory_gc_status_t;
 void gs_memory_gc_status(const gs_ref_memory_t *, gs_memory_gc_status_t *);
 void gs_memory_set_gc_status(gs_ref_memory_t *, const gs_memory_gc_status_t *);
-void gs_memory_set_vm_threshold(gs_ref_memory_t * mem, long val);
+void gs_memory_set_vm_threshold(gs_ref_memory_t * mem, size_t val);
 void gs_memory_set_vm_reclaim(gs_ref_memory_t * mem, bool enabled);
 
 /* ------ Initialization ------ */
diff --git a/base/gsmalloc.c b/base/gsmalloc.c
index 1fb4e9e3c..4a2c2c20a 100644
--- a/base/gsmalloc.c
+++ b/base/gsmalloc.c
@@ -90,7 +90,7 @@ static const gs_memory_procs_t gs_malloc_memory_procs =
 #define malloc_block_data\
         gs_malloc_block_t *next;\
         gs_malloc_block_t *prev;\
-        uint size;\
+        size_t size;\
         gs_memory_type_ptr_t type;\
         client_name_t cname
 struct malloc_block_data_s {
@@ -165,7 +165,7 @@ heap_available()
 
 /* Allocate various kinds of blocks. */
 static byte *
-gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
+gs_heap_alloc_bytes(gs_memory_t * mem, size_t size, client_name_t cname)
 {
     gs_malloc_memory_t *mmem = (gs_malloc_memory_t *) mem;
     byte *ptr = 0;
@@ -186,7 +186,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
         /* Definitely too large to allocate; also avoids overflow. */
         set_msg("exceeded limit");
     } else {
-        uint added = size + sizeof(gs_malloc_block_t);
+        size_t added = size + sizeof(gs_malloc_block_t);
 
         if (added <= size || mmem->limit - added < mmem->used)
             set_msg("exceeded limit");
@@ -223,7 +223,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
         gs_alloc_fill(ptr, gs_alloc_fill_alloc, size);
 #ifdef DEBUG
     if (gs_debug_c('a') || msg != ok_msg)
-        dmlprintf6(mem, "[a+]gs_malloc(%s)(%u) = 0x%lx: %s, used=%ld, max=%ld\n",
+        dmlprintf6(mem, "[a+]gs_malloc(%s)(%"PRIuSIZE") = 0x%lx: %s, used=%ld, max=%ld\n",
                    client_name_string(cname), size, (ulong) ptr, msg, mmem->used, mmem->max_used);
 #endif
     return ptr;
@@ -242,17 +242,17 @@ gs_heap_alloc_struct(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
     return ptr;
 }
 static byte *
-gs_heap_alloc_byte_array(gs_memory_t * mem, uint num_elements, uint elt_size,
+gs_heap_alloc_byte_array(gs_memory_t * mem, size_t num_elements, size_t elt_size,
                          client_name_t cname)
 {
-    ulong lsize = (ulong) num_elements * elt_size;
+    size_t lsize = (size_t) num_elements * elt_size;
 
-    if (lsize != (uint) lsize)
+    if (elt_size != 0 && lsize/elt_size != num_elements)
         return 0;
-    return gs_heap_alloc_bytes(mem, (uint) lsize, cname);
+    return gs_heap_alloc_bytes(mem, (size_t) lsize, cname);
 }
 static void *
-gs_heap_alloc_struct_array(gs_memory_t * mem, uint num_elements,
+gs_heap_alloc_struct_array(gs_memory_t * mem, size_t num_elements,
                            gs_memory_type_ptr_t pstype, client_name_t cname)
 {
     void *ptr =
@@ -265,14 +265,14 @@ gs_heap_alloc_struct_array(gs_memory_t * mem, uint num_elements,
     return ptr;
 }
 static void *
-gs_heap_resize_object(gs_memory_t * mem, void *obj, uint new_num_elements,
+gs_heap_resize_object(gs_memory_t * mem, void *obj, size_t new_num_elements,
                       client_name_t cname)
 {
     gs_malloc_memory_t *mmem = (gs_malloc_memory_t *) mem;
     gs_malloc_block_t *ptr = (gs_malloc_block_t *) obj - 1;
     gs_memory_type_ptr_t pstype = ptr->type;
-    uint old_size = gs_object_size(mem, obj) + sizeof(gs_malloc_block_t);
-    uint new_size =
+    size_t old_size = gs_object_size(mem, obj) + sizeof(gs_malloc_block_t);
+    size_t new_size =
         gs_struct_type_size(pstype) * new_num_elements +
         sizeof(gs_malloc_block_t);
     gs_malloc_block_t *new_ptr;
@@ -300,7 +300,7 @@ gs_heap_resize_object(gs_memory_t * mem, void *obj, uint new_num_elements,
                       gs_alloc_fill_alloc, new_size - old_size);
     return new_ptr + 1;
 }
-static uint
+static size_t
 gs_heap_object_size(gs_memory_t * mem, const void *ptr)
 {
     return ((const gs_malloc_block_t *)ptr)[-1].size;
@@ -318,7 +318,7 @@ gs_heap_free_object(gs_memory_t * mem, void *ptr, client_name_t cname)
     gs_memory_type_ptr_t pstype;
     struct_proc_finalize((*finalize));
 
-    if_debug3m('a', mem, "[a-]gs_free(%s) 0x%lx(%u)\n",
+    if_debug3m('a', mem, "[a-]gs_free(%s) 0x%lx(%"PRIuSIZE")\n",
                client_name_string(cname), (ulong) ptr,
                (ptr == 0 ? 0 : ((gs_malloc_block_t *) ptr)[-1].size));
     if (ptr == 0)
@@ -403,12 +403,12 @@ gs_heap_free_object(gs_memory_t * mem, void *ptr, client_name_t cname)
 #endif
 }
 static byte *
-gs_heap_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
+gs_heap_alloc_string(gs_memory_t * mem, size_t nbytes, client_name_t cname)
 {
     return gs_heap_alloc_bytes(mem, nbytes, cname);
 }
 static byte *
-gs_heap_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num,
+gs_heap_resize_string(gs_memory_t * mem, byte * data, size_t old_num, size_t new_num,
                       client_name_t cname)
 {
     if (gs_heap_object_type(mem, data) != &st_bytes)
@@ -417,7 +417,7 @@ gs_heap_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num
     return gs_heap_resize_object(mem, data, new_num, cname);
 }
 static void
-gs_heap_free_string(gs_memory_t * mem, byte * data, uint nbytes,
+gs_heap_free_string(gs_memory_t * mem, byte * data, size_t nbytes,
                     client_name_t cname)
 {
     /****** SHOULD CHECK SIZE IF DEBUGGING ******/
@@ -503,7 +503,7 @@ gs_heap_free_all(gs_memory_t * mem, uint free_mask, client_name_t cname)
 
         for (; bp != 0; bp = np) {
             np = bp->next;
-            if_debug3m('a', mem, "[a]gs_heap_free_all(%s) 0x%lx(%u)\n",
+            if_debug3m('a', mem, "[a]gs_heap_free_all(%s) 0x%lx(%"PRIuSIZE")\n",
                        client_name_string(bp->cname), (ulong) (bp + 1),
                        bp->size);
             gs_alloc_fill(bp + 1, gs_alloc_fill_free, bp->size);
diff --git a/base/gsmalloc.h b/base/gsmalloc.h
index c8acd1085..1f2f5b2bd 100644
--- a/base/gsmalloc.h
+++ b/base/gsmalloc.h
@@ -27,9 +27,9 @@ typedef struct gs_malloc_block_s gs_malloc_block_t;
 typedef struct gs_malloc_memory_s {
     gs_memory_common;
     gs_malloc_block_t *allocated;
-    ulong limit;
-    ulong used;
-    ulong max_used;
+    size_t limit;
+    size_t used;
+    size_t max_used;
     gx_monitor_t *monitor;	/* monitor to serialize access to functions */
 } gs_malloc_memory_t;
 
diff --git a/base/gsmchunk.c b/base/gsmchunk.c
index fecf0ff26..10629b1ef 100644
--- a/base/gsmchunk.c
+++ b/base/gsmchunk.c
@@ -966,71 +966,71 @@ chunk_obj_alloc(gs_memory_t *mem, uint size, gs_memory_type_ptr_t type, client_n
 }
 
 static byte *
-chunk_alloc_bytes_immovable(gs_memory_t * mem, uint size, client_name_t cname)
+chunk_alloc_bytes_immovable(gs_memory_t * mem, size_t size, client_name_t cname)
 {
     return chunk_obj_alloc(mem, size, &st_bytes, cname);
 }
 
 static byte *
-chunk_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
+chunk_alloc_bytes(gs_memory_t * mem, size_t size, client_name_t cname)
 {
     return chunk_obj_alloc(mem, size, &st_bytes, cname);
 }
 
 static void *
 chunk_alloc_struct_immovable(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
-                         client_name_t cname)
+                             client_name_t cname)
 {
     return chunk_obj_alloc(mem, pstype->ssize, pstype, cname);
 }
 
 static void *
 chunk_alloc_struct(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
-               client_name_t cname)
+                   client_name_t cname)
 {
     return chunk_obj_alloc(mem, pstype->ssize, pstype, cname);
 }
 
 static byte *
-chunk_alloc_byte_array_immovable(gs_memory_t * mem, uint num_elements,
-                             uint elt_size, client_name_t cname)
+chunk_alloc_byte_array_immovable(gs_memory_t * mem, size_t num_elements,
+                                 size_t elt_size, client_name_t cname)
 {
     return chunk_alloc_bytes(mem, num_elements * elt_size, cname);
 }
 
 static byte *
-chunk_alloc_byte_array(gs_memory_t * mem, uint num_elements, uint elt_size,
+chunk_alloc_byte_array(gs_memory_t * mem, size_t num_elements, size_t elt_size,
                    client_name_t cname)
 {
     return chunk_alloc_bytes(mem, num_elements * elt_size, cname);
 }
 
 static void *
-chunk_alloc_struct_array_immovable(gs_memory_t * mem, uint num_elements,
-                           gs_memory_type_ptr_t pstype, client_name_t cname)
+chunk_alloc_struct_array_immovable(gs_memory_t * mem, size_t num_elements,
+                                   gs_memory_type_ptr_t pstype, client_name_t cname)
 {
     return chunk_obj_alloc(mem, num_elements * pstype->ssize, pstype, cname);
 }
 
 static void *
-chunk_alloc_struct_array(gs_memory_t * mem, uint num_elements,
-                     gs_memory_type_ptr_t pstype, client_name_t cname)
+chunk_alloc_struct_array(gs_memory_t * mem, size_t num_elements,
+                         gs_memory_type_ptr_t pstype, client_name_t cname)
 {
     return chunk_obj_alloc(mem, num_elements * pstype->ssize, pstype, cname);
 }
 
 static void *
-chunk_resize_object(gs_memory_t * mem, void *ptr, uint new_num_elements, client_name_t cname)
+chunk_resize_object(gs_memory_t * mem, void *ptr, size_t new_num_elements, client_name_t cname)
 {
     /* This isn't particularly efficient, but it is rarely used */
     chunk_obj_node_t *obj = (chunk_obj_node_t *)(((byte *)ptr) - SIZEOF_ROUND_ALIGN(chunk_obj_node_t));
-    ulong new_size = (obj->type->ssize * new_num_elements);
-    ulong old_size = obj->size - obj->padding;
+    size_t new_size = (obj->type->ssize * new_num_elements);
+    size_t old_size = obj->size - obj->padding;
     /* get the type from the old object */
     gs_memory_type_ptr_t type = obj->type;
     void *new_ptr;
     gs_memory_chunk_t *cmem = (gs_memory_chunk_t *)mem;
-    ulong save_max_used = cmem->max_used;
+    size_t save_max_used = cmem->max_used;
 
     if (new_size == old_size)
         return ptr;
@@ -1048,7 +1048,7 @@ static void
 chunk_free_object(gs_memory_t *mem, void *ptr, client_name_t cname)
 {
     gs_memory_chunk_t * const cmem = (gs_memory_chunk_t *)mem;
-    int obj_node_size;
+    size_t obj_node_size;
     chunk_obj_node_t *obj;
     struct_proc_finalize((*finalize));
     chunk_free_node_t **ap, **gtp, **ltp;
@@ -1296,30 +1296,30 @@ chunk_free_object(gs_memory_t *mem, void *ptr, client_name_t cname)
 }
 
 static byte *
-chunk_alloc_string_immovable(gs_memory_t * mem, uint nbytes, client_name_t cname)
+chunk_alloc_string_immovable(gs_memory_t * mem, size_t nbytes, client_name_t cname)
 {
     /* we just alloc bytes here */
     return chunk_alloc_bytes(mem, nbytes, cname);
 }
 
 static byte *
-chunk_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
+chunk_alloc_string(gs_memory_t * mem, size_t nbytes, client_name_t cname)
 {
     /* we just alloc bytes here */
     return chunk_alloc_bytes(mem, nbytes, cname);
 }
 
 static byte *
-chunk_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num,
-                client_name_t cname)
+chunk_resize_string(gs_memory_t * mem, byte * data, size_t old_num, size_t new_num,
+                    client_name_t cname)
 {
     /* just resize object - ignores old_num */
     return chunk_resize_object(mem, data, new_num, cname);
 }
 
 static void
-chunk_free_string(gs_memory_t * mem, byte * data, uint nbytes,
-              client_name_t cname)
+chunk_free_string(gs_memory_t * mem, byte * data, size_t nbytes,
+                  client_name_t cname)
 {
     chunk_free_object(mem, data, cname);
 }
@@ -1393,7 +1393,7 @@ chunk_consolidate_free(gs_memory_t *mem)
 }
 
 /* accessors to get size and type given the pointer returned to the client */
-static uint
+static size_t
 chunk_object_size(gs_memory_t * mem, const void *ptr)
 {
     chunk_obj_node_t *obj = (chunk_obj_node_t *)(((byte *)ptr) - SIZEOF_ROUND_ALIGN(chunk_obj_node_t));
diff --git a/base/gsmdebug.h b/base/gsmdebug.h
index 6685d62d3..2b332c5a2 100644
--- a/base/gsmdebug.h
+++ b/base/gsmdebug.h
@@ -35,12 +35,12 @@ extern const byte
 #define gs_alloc_debug gs_debug['@']
 
 /* Conditionally fill unoccupied blocks with a pattern. */
-extern void gs_alloc_memset(void *, int /*byte */ , ulong);
+extern void gs_alloc_memset(void *, int /*byte */ , size_t);
 
 #ifdef DEBUG
 #  define gs_alloc_fill(ptr, fill, len)                              \
      BEGIN                                                           \
-     if ( gs_alloc_debug ) gs_alloc_memset(ptr, fill, (ulong)(len)); \
+     if ( gs_alloc_debug ) gs_alloc_memset(ptr, fill, (size_t)(len)); \
      VALGRIND_MAKE_MEM_UNDEFINED(ptr,(ulong)(len));                  \
      END
 #else
diff --git a/base/gsmemory.c b/base/gsmemory.c
index 5557db083..d84474b9c 100644
--- a/base/gsmemory.c
+++ b/base/gsmemory.c
@@ -82,9 +82,9 @@ reloc_const_bytestring(gs_const_bytestring *pbs, gc_state_t *gcst)
 /* Fill an unoccupied block with a pattern. */
 /* Note that the block size may be too large for a single memset. */
 void
-gs_alloc_memset(void *ptr, int /*byte */ fill, ulong lsize)
+gs_alloc_memset(void *ptr, int /*byte */ fill, size_t lsize)
 {
-    ulong msize = lsize;
+    size_t msize = lsize;
     char *p = ptr;
     int isize;
 
@@ -99,7 +99,7 @@ gs_alloc_memset(void *ptr, int /*byte */ fill, ulong lsize)
  * If obj != 0, pstype is used only for checking (in DEBUG configurations).
  */
 void *
-gs_resize_struct_array(gs_memory_t *mem, void *obj, uint num_elements,
+gs_resize_struct_array(gs_memory_t *mem, void *obj, size_t num_elements,
                        gs_memory_type_ptr_t pstype, client_name_t cname)
 {
     if (obj == 0)
@@ -133,7 +133,7 @@ gs_ignore_free_object(gs_memory_t * mem, void *data, client_name_t cname)
 {
 }
 void
-gs_ignore_free_string(gs_memory_t * mem, byte * data, uint nbytes,
+gs_ignore_free_string(gs_memory_t * mem, byte * data, size_t nbytes,
                       client_name_t cname)
 {
 }
@@ -149,7 +149,7 @@ gs_free_const_object(gs_memory_t * mem, const void *data, client_name_t cname)
     gs_free_object(mem, u.w, cname);
 }
 void
-gs_free_const_string(gs_memory_t * mem, const byte * data, uint nbytes,
+gs_free_const_string(gs_memory_t * mem, const byte * data, size_t nbytes,
                      client_name_t cname)
 {
     union { const byte *r; byte *w; } u;
diff --git a/base/gsmemory.h b/base/gsmemory.h
index 2c7c483fc..a5d3ad3da 100644
--- a/base/gsmemory.h
+++ b/base/gsmemory.h
@@ -76,13 +76,13 @@ typedef struct gs_memory_status_s {
      * the parent of the memory manager.  It includes space used for
      * allocated data, space available for allocation, and overhead.
      */
-    ulong allocated;
+    size_t allocated;
     /*
      * "Used" space is the amount of space used by allocated data
      * plus overhead.
      */
-    ulong used;
-    ulong max_used;
+    size_t used;
+    size_t max_used;
     /* used when wrapping if underlying allocator must be thread safe */
     bool is_thread_safe;
 } gs_memory_status_t;
@@ -97,7 +97,7 @@ typedef struct gs_memory_status_s {
                  */
 
 #define gs_memory_t_proc_alloc_bytes(proc, mem_t)\
-  byte *proc(mem_t *mem, uint nbytes, client_name_t cname)
+  byte *proc(mem_t *mem, size_t nbytes, client_name_t cname)
 
 #define gs_alloc_bytes_immovable(mem, nbytes, cname)\
   ((mem)->procs.alloc_bytes_immovable(mem, nbytes, cname))
@@ -114,7 +114,7 @@ typedef struct gs_memory_status_s {
                  */
 
 #define gs_memory_t_proc_resize_object(proc, mem_t)\
-  void *proc(mem_t *mem, void *obj, uint new_num_elements,\
+  void *proc(mem_t *mem, void *obj, size_t new_num_elements,\
              client_name_t cname)
 
 #define gs_resize_object(mem, obj, newn, cname)\
@@ -260,7 +260,7 @@ typedef struct gs_memory_procs_s {
      */
 
 #define gs_memory_proc_alloc_byte_array(proc)\
-  byte *proc(gs_memory_t *mem, uint num_elements, uint elt_size,\
+  byte *proc(gs_memory_t *mem, size_t num_elements, size_t elt_size,\
     client_name_t cname)
 #define gs_alloc_byte_array(mem, nelts, esize, cname)\
   (*(mem)->procs.alloc_byte_array)(mem, nelts, esize, cname)
@@ -274,7 +274,7 @@ typedef struct gs_memory_procs_s {
      */
 
 #define gs_memory_proc_alloc_struct_array(proc)\
-  void *proc(gs_memory_t *mem, uint num_elements,\
+  void *proc(gs_memory_t *mem, size_t num_elements,\
     gs_memory_type_ptr_t pstype, client_name_t cname)
 #define gs_alloc_struct_array(mem, nelts, typ, pstype, cname)\
   (typ *)(*(mem)->procs.alloc_struct_array)(mem, nelts, pstype, cname)
@@ -288,7 +288,7 @@ typedef struct gs_memory_procs_s {
      */
 
 #define gs_memory_proc_object_size(proc)\
-  uint proc(gs_memory_t *mem, const void *obj)
+  size_t proc(gs_memory_t *mem, const void *obj)
 #define gs_object_size(mem, obj)\
   (*(mem)->procs.object_size)(mem, obj)
     gs_memory_proc_object_size((*object_size));
@@ -310,7 +310,7 @@ typedef struct gs_memory_procs_s {
      */
 
 #define gs_memory_proc_alloc_string(proc)\
-  byte *proc(gs_memory_t *mem, uint nbytes, client_name_t cname)
+  byte *proc(gs_memory_t *mem, size_t nbytes, client_name_t cname)
 #define gs_alloc_string(mem, nbytes, cname)\
   (*(mem)->procs.alloc_string)(mem, nbytes, cname)
     gs_memory_proc_alloc_string((*alloc_string));
@@ -324,7 +324,7 @@ typedef struct gs_memory_procs_s {
      */
 
 #define gs_memory_proc_resize_string(proc)\
-  byte *proc(gs_memory_t *mem, byte *data, uint old_num, uint new_num,\
+  byte *proc(gs_memory_t *mem, byte *data, size_t old_num, size_t new_num,\
     client_name_t cname)
 #define gs_resize_string(mem, data, oldn, newn, cname)\
   (*(mem)->procs.resize_string)(mem, data, oldn, newn, cname)
@@ -335,7 +335,7 @@ typedef struct gs_memory_procs_s {
      */
 
 #define gs_memory_proc_free_string(proc)\
-  void proc(gs_memory_t *mem, byte *data, uint nbytes,\
+  void proc(gs_memory_t *mem, byte *data, size_t nbytes,\
     client_name_t cname)
 #define gs_free_string(mem, data, nbytes, cname)\
   (*(mem)->procs.free_string)(mem, data, nbytes, cname)
@@ -411,7 +411,7 @@ typedef struct gs_memory_procs_s {
  */
 void gs_free_const_object(gs_memory_t *mem, const void *data,
                           client_name_t cname);
-void gs_free_const_string(gs_memory_t *mem, const byte *data, uint nbytes,
+void gs_free_const_string(gs_memory_t *mem, const byte *data, size_t nbytes,
                           client_name_t cname);
 
 /*
@@ -427,7 +427,7 @@ void gs_free_const_bytestring(gs_memory_t *mem, gs_const_bytestring *pbs,
  * Either allocate (if obj == 0) or resize (if obj != 0) a structure array.
  * If obj != 0, pstype is used only for checking (in DEBUG configurations).
  */
-void *gs_resize_struct_array(gs_memory_t *mem, void *obj, uint num_elements,
+void *gs_resize_struct_array(gs_memory_t *mem, void *obj, size_t num_elements,
                              gs_memory_type_ptr_t pstype,
                              client_name_t cname);
 
diff --git a/base/gsmemret.c b/base/gsmemret.c
index ca39b699f..667a0f684 100644
--- a/base/gsmemret.c
+++ b/base/gsmemret.c
@@ -178,7 +178,7 @@ gs_forward_consolidate_free(gs_memory_t * mem)
     DO_FORWARD(target->procs.consolidate_free(target));
 }
 static byte *
-gs_retrying_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
+gs_retrying_alloc_bytes(gs_memory_t * mem, size_t size, client_name_t cname)
 {
     RETURN_RETRYING(
                     byte *,
@@ -186,7 +186,7 @@ gs_retrying_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
                     );
 }
 static byte *
-gs_retrying_alloc_bytes_immovable(gs_memory_t * mem, uint size,
+gs_retrying_alloc_bytes_immovable(gs_memory_t * mem, size_t size,
                                 client_name_t cname)
 {
     RETURN_RETRYING(
@@ -213,7 +213,7 @@ gs_retrying_alloc_struct_immovable(gs_memory_t * mem,
                     );
 }
 static byte *
-gs_retrying_alloc_byte_array(gs_memory_t * mem, uint num_elements, uint elt_size,
+gs_retrying_alloc_byte_array(gs_memory_t * mem, size_t num_elements, size_t elt_size,
                            client_name_t cname)
 {
     RETURN_RETRYING(
@@ -223,8 +223,8 @@ gs_retrying_alloc_byte_array(gs_memory_t * mem, uint num_elements, uint elt_size
                     );
 }
 static byte *
-gs_retrying_alloc_byte_array_immovable(gs_memory_t * mem, uint num_elements,
-                                     uint elt_size, client_name_t cname)
+gs_retrying_alloc_byte_array_immovable(gs_memory_t * mem, size_t num_elements,
+                                       size_t elt_size, client_name_t cname)
 {
     RETURN_RETRYING(
                     byte *,
@@ -234,8 +234,8 @@ gs_retrying_alloc_byte_array_immovable(gs_memory_t * mem, uint num_elements,
                     );
 }
 static void *
-gs_retrying_alloc_struct_array(gs_memory_t * mem, uint num_elements,
-                           gs_memory_type_ptr_t pstype, client_name_t cname)
+gs_retrying_alloc_struct_array(gs_memory_t * mem, size_t num_elements,
+                               gs_memory_type_ptr_t pstype, client_name_t cname)
 {
     RETURN_RETRYING(
                     void *,
@@ -244,19 +244,21 @@ gs_retrying_alloc_struct_array(gs_memory_t * mem, uint num_elements,
                     );
 }
 static void *
-gs_retrying_alloc_struct_array_immovable(gs_memory_t * mem, uint num_elements,
-                           gs_memory_type_ptr_t pstype, client_name_t cname)
+gs_retrying_alloc_struct_array_immovable(gs_memory_t * mem, size_t num_elements,
+                                         gs_memory_type_ptr_t pstype,
+                                         client_name_t cname)
 {
     RETURN_RETRYING(
                     void *,
                     target->procs.alloc_struct_array_immovable(target,
-                                                        num_elements, pstype,
-                                                        cname)
+                                                               num_elements,
+                                                               pstype,
+                                                               cname)
                     );
 }
 static void *
-gs_retrying_resize_object(gs_memory_t * mem, void *obj, uint new_num_elements,
-                        client_name_t cname)
+gs_retrying_resize_object(gs_memory_t * mem, void *obj, size_t new_num_elements,
+                          client_name_t cname)
 {
     RETURN_RETRYING(
                     void *,
@@ -264,7 +266,7 @@ gs_retrying_resize_object(gs_memory_t * mem, void *obj, uint new_num_elements,
                                                 cname)
                     );
 }
-static uint
+static size_t
 gs_forward_object_size(gs_memory_t * mem, const void *ptr)
 {
     DO_FORWARD(return target->procs.object_size(target, ptr));
@@ -280,7 +282,7 @@ gs_forward_free_object(gs_memory_t * mem, void *ptr, client_name_t cname)
     DO_FORWARD(target->procs.free_object(target, ptr, cname));
 }
 static byte *
-gs_retrying_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
+gs_retrying_alloc_string(gs_memory_t * mem, size_t nbytes, client_name_t cname)
 {
     RETURN_RETRYING(
                     byte *,
@@ -288,7 +290,7 @@ gs_retrying_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
                     );
 }
 static byte *
-gs_retrying_alloc_string_immovable(gs_memory_t * mem, uint nbytes,
+gs_retrying_alloc_string_immovable(gs_memory_t * mem, size_t nbytes,
                                  client_name_t cname)
 {
     RETURN_RETRYING(
@@ -297,9 +299,8 @@ gs_retrying_alloc_string_immovable(gs_memory_t * mem, uint nbytes,
                     );
 }
 static byte *
-gs_retrying_resize_string(gs_memory_t * mem, byte * data, uint old_num,
-                        uint new_num,
-                        client_name_t cname)
+gs_retrying_resize_string(gs_memory_t * mem, byte * data, size_t old_num,
+                          size_t new_num, client_name_t cname)
 {
     RETURN_RETRYING(
                     byte *,
@@ -308,7 +309,7 @@ gs_retrying_resize_string(gs_memory_t * mem, byte * data, uint old_num,
                     );
 }
 static void
-gs_forward_free_string(gs_memory_t * mem, byte * data, uint nbytes,
+gs_forward_free_string(gs_memory_t * mem, byte * data, size_t nbytes,
                       client_name_t cname)
 {
     DO_FORWARD(target->procs.free_string(target, data, nbytes, cname));
diff --git a/base/gsnogc.c b/base/gsnogc.c
index 994952907..d36588d3b 100644
--- a/base/gsnogc.c
+++ b/base/gsnogc.c
@@ -24,26 +24,26 @@
 
 /* String allocations reduces to simple byte allocations. */
 static byte *
-nogc_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
+nogc_alloc_string(gs_memory_t * mem, size_t nbytes, client_name_t cname)
 {
     return gs_alloc_bytes(mem, nbytes, cname);
 }
 
 /* Free a string. */
 static void
-nogc_free_string(gs_memory_t * mem, byte * str, uint size, client_name_t cname)
+nogc_free_string(gs_memory_t * mem, byte * str, size_t size, client_name_t cname)
 {
     gs_free_object(mem, str, cname);
 }
 
 static byte *
-nogc_alloc_string_immovable(gs_memory_t * mem, uint nbytes, client_name_t cname)
+nogc_alloc_string_immovable(gs_memory_t * mem, size_t nbytes, client_name_t cname)
 {
     return gs_alloc_bytes(mem, nbytes, cname);
 }
 
 static byte *
-nogc_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num, client_name_t cname)
+nogc_resize_string(gs_memory_t * mem, byte * data, size_t old_num, size_t new_num, client_name_t cname)
 {
     return gs_resize_object(mem, data, new_num, cname);
 }
diff --git a/base/gsstype.h b/base/gsstype.h
index 668ce853c..4642db173 100644
--- a/base/gsstype.h
+++ b/base/gsstype.h
@@ -82,8 +82,16 @@ typedef struct enum_ptr_s {
  */
 typedef struct struct_shared_procs_s struct_shared_procs_t;
 
+/*
+ * Objects within the 'obj' allocator are currently limited to be uint's,
+ * even though the interface allows for size_t's. This means that gc'd
+ * allocations are never bigger than 4Gig. To change this, change the
+ * following type, at the cost of more overhead for each object.
+ */
+typedef uint obj_size_t;
+
 struct gs_memory_struct_type_s {
-        uint ssize;
+        obj_size_t ssize;
         struct_name_t sname;
 
         /* ------ Procedures shared among many structure types. ------ */
diff --git a/base/gxalloc.h b/base/gxalloc.h
index 53d8724ed..e81c29886 100644
--- a/base/gxalloc.h
+++ b/base/gxalloc.h
@@ -319,8 +319,8 @@ typedef struct ref_s ref;
 struct gs_ref_memory_s {
     /* The following are set at initialization time. */
     gs_memory_common;
-    uint clump_size;
-    uint large_size;		/* min size to give large object */
+    size_t clump_size;
+    size_t large_size;		/* min size to give large object */
                                 /* its own clump: must be */
                                 /* 1 mod obj_align_mod */
     uint space;			/* a_local, a_global, a_system */
@@ -333,20 +333,20 @@ struct gs_ref_memory_s {
     /* The following are updated dynamically. */
     bool is_controlled;		/* if true, this allocator doesn't manage */
                                 /* its own clumps */
-    ulong limit;		/* signal a VMerror when total */
+    size_t limit;		/* signal a VMerror when total */
                                 /* allocated exceeds this */
     clump_t *root;		/* root of clump splay tree */
     clump_t *cc;		/* current clump */
     clump_locator_t cfreed;	/* clump where last object freed */
-    ulong allocated;		/* total size of all clumps */
+    size_t allocated;		/* total size of all clumps */
                                 /* allocated at this save level */
-    ulong gc_allocated;		/* value of (allocated + */
+    size_t gc_allocated;	/* value of (allocated + */
                                 /* previous_status.allocated) after last GC */
     struct lost_ {		/* space freed and 'lost' (not put on a */
                                 /* freelist) */
-        ulong objects;
-        ulong refs;
-        ulong strings;
+        size_t objects;
+        size_t refs;
+        size_t strings;
     } lost;
     /*
      * The following are for the interpreter's convenience: the
@@ -369,7 +369,7 @@ struct gs_ref_memory_s {
     struct alloc_save_s *reloc_saved;	/* for GC */
     gs_memory_status_t previous_status;		/* total allocated & used */
                                 /* in outer save levels */
-    uint largest_free_size;	/* largest (aligned) size on large block list */
+    size_t largest_free_size;	/* largest (aligned) size on large block list */
     /* We put the freelists last to keep the scalar offsets small. */
     obj_header_t *freelists[num_freelists];
 };
diff --git a/base/gxobj.h b/base/gxobj.h
index d02296fd0..6505f8253 100644
--- a/base/gxobj.h
+++ b/base/gxobj.h
@@ -122,7 +122,7 @@ typedef struct obj_header_data_s {
             unsigned _:1, back:obj_mb_bits;
         } b;
     } f;
-    uint size;
+    obj_size_t size; /* Note, not size_t! */
     union _t {
         gs_memory_type_ptr_t type;
         size_t reloc;
@@ -164,7 +164,7 @@ typedef struct obj_header_data_s {
 #endif
 #define obj_align_mask (obj_align_mod-1)
 #define obj_align_round(siz)\
-  (size_t)(((siz) + obj_align_mask) & -obj_align_mod)
+  (obj_size_t)(((siz) + obj_align_mask) & -obj_align_mod)
 #define obj_size_round(siz)\
   obj_align_round((siz) + sizeof(obj_header_t))
 
diff --git a/base/mkromfs.c b/base/mkromfs.c
index bd61f489e..f6e4d6f9a 100644
--- a/base/mkromfs.c
+++ b/base/mkromfs.c
@@ -289,30 +289,30 @@ gs_log_error(int err, const char *file, int line)
  * The following is a REALLY minimal gs_memory_t for use by the gp_ functions
  *******************************************************************************/
 
-byte *minimal_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname);
-byte *minimal_alloc_byte_array(gs_memory_t * mem, uint num_elements,
-                             uint elt_size, client_name_t cname);
+byte *minimal_alloc_bytes(gs_memory_t * mem, size_t size, client_name_t cname);
+byte *minimal_alloc_byte_array(gs_memory_t * mem, size_t num_elements,
+                               size_t elt_size, client_name_t cname);
 void *minimal_alloc_struct(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
-               client_name_t cname);
+                           client_name_t cname);
 void minimal_free_object(gs_memory_t * mem, void * data, client_name_t cname);
-void minimal_free_string(gs_memory_t * mem, byte * data, uint nbytes, client_name_t cname);
+void minimal_free_string(gs_memory_t * mem, byte * data, size_t nbytes, client_name_t cname);
 
 byte *
-minimal_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
+minimal_alloc_bytes(gs_memory_t * mem, size_t size, client_name_t cname)
 {
     return malloc(size);
 }
 
 byte *
-minimal_alloc_byte_array(gs_memory_t * mem, uint num_elements,
-                             uint elt_size, client_name_t cname)
+minimal_alloc_byte_array(gs_memory_t * mem, size_t num_elements,
+                         size_t elt_size, client_name_t cname)
 {
     return malloc(num_elements * elt_size);
 }
 
 void *
 minimal_alloc_struct(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
-               client_name_t cname)
+                     client_name_t cname)
 {
     return malloc(pstype->ssize);
 }
@@ -325,7 +325,7 @@ minimal_free_object(gs_memory_t * mem, void * data, client_name_t cname)
 }
 
 void
-minimal_free_string(gs_memory_t * mem, byte * data, uint nbytes, client_name_t cname)
+minimal_free_string(gs_memory_t * mem, byte * data, size_t nbytes, client_name_t cname)
 {
     free(data);
     return;
diff --git a/psi/ilocate.c b/psi/ilocate.c
index 367adfab7..35916087a 100644
--- a/psi/ilocate.c
+++ b/psi/ilocate.c
@@ -156,7 +156,7 @@ gc_locate(const void *ptr, gc_state_t * gcst)
 /* Define the structure for temporarily saving allocator state. */
 typedef struct alloc_temp_save_s {
         clump_t *cc;
-        uint rsize;
+        obj_size_t rsize;
         ref rlast;
 } alloc_temp_save_t;
 /* Temporarily save the state of an allocator. */
@@ -266,7 +266,7 @@ ialloc_validate_memory(const gs_ref_memory_t * mem, gc_state_t * gcst)
             for (pfree = mem->freelists[i]; pfree != 0;
                  pfree = *(const obj_header_t * const *)pfree
                 ) {
-                uint size = pfree[-1].o_size;
+                obj_size_t size = pfree[-1].o_size;
 
                 if (pfree[-1].o_type != &st_free) {
                     mlprintf3((gs_memory_t *)mem, "Non-free object 0x%lx(%u) on freelist %i!\n",
@@ -277,7 +277,7 @@ ialloc_validate_memory(const gs_ref_memory_t * mem, gc_state_t * gcst)
                  (i != LARGE_FREELIST_INDEX &&
                  (size < free_size - obj_align_mask || size > free_size))) {
                     mlprintf3((gs_memory_t *)mem, "Object 0x%lx(%u) size wrong on freelist %i!\n",
-                              (ulong) pfree, size, i);
+                              (ulong) pfree, (uint)size, i);
                     break;
                 }
             }