diff --git a/Pal/include/lib/memmgr.h b/Pal/include/lib/memmgr.h
index aa947664..4ed9877c 100644
--- a/Pal/include/lib/memmgr.h
+++ b/Pal/include/lib/memmgr.h
@@ -60,7 +60,7 @@ typedef struct mem_obj {
 DEFINE_LIST(mem_area);
 typedef struct mem_area {
     LIST_TYPE(mem_area) __list;
-    unsigned int size;
+    size_t size;
     MEM_OBJ_TYPE objs[];
 } MEM_AREA_TYPE, *MEM_AREA;
 
@@ -80,35 +80,35 @@ typedef struct mem_mgr {
 #define __MAX_MEM_SIZE(size) (__MIN_MEM_SIZE() + __SUM_OBJ_SIZE(size))
 
 #ifdef ALLOC_ALIGNMENT
-static inline int size_align_down(int size) {
+static inline size_t size_align_down(size_t size) {
     assert(IS_POWER_OF_2(ALLOC_ALIGNMENT));
-    int s = __MAX_MEM_SIZE(size) - sizeof(MEM_MGR_TYPE);
-    int p = s - ALIGN_DOWN_POW2(s, ALLOC_ALIGNMENT);
-    int o = __SUM_OBJ_SIZE(1);
+    size_t s = __MAX_MEM_SIZE(size) - sizeof(MEM_MGR_TYPE);
+    size_t p = s - ALIGN_DOWN_POW2(s, ALLOC_ALIGNMENT);
+    size_t o = __SUM_OBJ_SIZE(1);
     return size - p / o - (p % o ? 1 : 0);
 }
 
-static inline int size_align_up(int size) {
+static inline size_t size_align_up(size_t size) {
     assert(IS_POWER_OF_2(ALLOC_ALIGNMENT));
-    int s = __MAX_MEM_SIZE(size) - sizeof(MEM_MGR_TYPE);
-    int p = ALIGN_UP_POW2(s, ALLOC_ALIGNMENT) - s;
-    int o = __SUM_OBJ_SIZE(1);
+    size_t s = __MAX_MEM_SIZE(size) - sizeof(MEM_MGR_TYPE);
+    size_t p = ALIGN_UP_POW2(s, ALLOC_ALIGNMENT) - s;
+    size_t o = __SUM_OBJ_SIZE(1);
     return size + p / o;
 }
 
-static inline int init_align_down(int size) {
+static inline size_t init_align_down(size_t size) {
     assert(IS_POWER_OF_2(ALLOC_ALIGNMENT));
-    int s = __MAX_MEM_SIZE(size);
-    int p = s - ALIGN_DOWN_POW2(s, ALLOC_ALIGNMENT);
-    int o = __SUM_OBJ_SIZE(1);
+    size_t s = __MAX_MEM_SIZE(size);
+    size_t p = s - ALIGN_DOWN_POW2(s, ALLOC_ALIGNMENT);
+    size_t o = __SUM_OBJ_SIZE(1);
     return size - p / o - (p % o ? 1 : 0);
 }
 
-static inline int init_align_up(int size) {
+static inline size_t init_align_up(size_t size) {
     assert(IS_POWER_OF_2(ALLOC_ALIGNMENT));
-    int s = __MAX_MEM_SIZE(size);
-    int p = ALIGN_UP_POW2(s, ALLOC_ALIGNMENT) - s;
-    int o = __SUM_OBJ_SIZE(1);
+    size_t s = __MAX_MEM_SIZE(size);
+    size_t p = ALIGN_UP_POW2(s, ALLOC_ALIGNMENT) - s;
+    size_t o = __SUM_OBJ_SIZE(1);
     return size + p / o;
 }
 #endif
@@ -122,11 +122,12 @@ static inline void __set_free_mem_area(MEM_AREA area, MEM_MGR mgr) {
     mgr->active_area = area;
 }
 
-static inline MEM_MGR create_mem_mgr(unsigned int size) {
+static inline MEM_MGR create_mem_mgr(size_t size) {
     void* mem = system_malloc(__MAX_MEM_SIZE(size));
     MEM_AREA area;
     MEM_MGR mgr;
 
+    assert(size);
     if (!mem)
         return NULL;
 
@@ -145,9 +146,10 @@ static inline MEM_MGR create_mem_mgr(unsigned int size) {
     return mgr;
 }
 
-static inline MEM_MGR enlarge_mem_mgr(MEM_MGR mgr, unsigned int size) {
+static inline MEM_MGR enlarge_mem_mgr(MEM_MGR mgr, size_t size) {
     MEM_AREA area;
 
+    assert(size);
     area = (MEM_AREA)system_malloc(sizeof(MEM_AREA_TYPE) + __SUM_OBJ_SIZE(size));
     if (!area)
         return NULL;
@@ -202,9 +204,10 @@ static inline OBJ_TYPE* get_mem_obj_from_mgr(MEM_MGR mgr) {
     return &mobj->obj;
 }
 
-static inline OBJ_TYPE* get_mem_obj_from_mgr_enlarge(MEM_MGR mgr, unsigned int size) {
+static inline OBJ_TYPE* get_mem_obj_from_mgr_enlarge(MEM_MGR mgr, size_t size) {
     MEM_OBJ mobj;
 
+    assert(size);
     SYSTEM_LOCK();
     while (mgr->obj == mgr->obj_top && LISTP_EMPTY(&mgr->free_list)) {
         MEM_AREA area;
@@ -218,9 +221,6 @@ static inline OBJ_TYPE* get_mem_obj_from_mgr_enlarge(MEM_MGR mgr, unsigned int s
 
         SYSTEM_UNLOCK();
 
-        if (!size)
-            return NULL;
-
         /* There can be concurrent attempt to try to enlarge the
            allocator, but we prevent deadlocks or crashes. */
         area = (MEM_AREA)system_malloc(sizeof(MEM_AREA_TYPE) + __SUM_OBJ_SIZE(size));
diff --git a/Pal/include/lib/slabmgr.h b/Pal/include/lib/slabmgr.h
index df6e8c87..69f00168 100644
--- a/Pal/include/lib/slabmgr.h
+++ b/Pal/include/lib/slabmgr.h
@@ -85,7 +85,7 @@ DEFINE_LIST(slab_area);
 
 typedef struct __attribute__((packed)) slab_area {
     LIST_TYPE(slab_area) __list;
-    unsigned int size;
+    size_t size;
     unsigned char pad[AREA_PADDING];
     unsigned char raw[];
 } SLAB_AREA_TYPE, *SLAB_AREA;
@@ -175,35 +175,35 @@ typedef struct __attribute__((packed)) large_mem_obj {
 #define __INIT_MAX_MEM_SIZE(size) (__INIT_MIN_MEM_SIZE() + __INIT_SUM_OBJ_SIZE(size))
 
 #ifdef ALLOC_ALIGNMENT
-static inline int size_align_down(int slab_size, int size) {
+static inline size_t size_align_down(size_t slab_size, size_t size) {
     assert(IS_POWER_OF_2(ALLOC_ALIGNMENT));
-    int s = __MAX_MEM_SIZE(slab_size, size);
-    int p = s - ALIGN_DOWN_POW2(s, ALLOC_ALIGNMENT);
-    int o = __SUM_OBJ_SIZE(slab_size, 1);
+    size_t s = __MAX_MEM_SIZE(slab_size, size);
+    size_t p = s - ALIGN_DOWN_POW2(s, ALLOC_ALIGNMENT);
+    size_t o = __SUM_OBJ_SIZE(slab_size, 1);
     return size - p / o - (p % o ? 1 : 0);
 }
 
-static inline int size_align_up(int slab_size, int size) {
+static inline size_t size_align_up(size_t slab_size, size_t size) {
     assert(IS_POWER_OF_2(ALLOC_ALIGNMENT));
-    int s = __MAX_MEM_SIZE(slab_size, size);
-    int p = ALIGN_UP_POW2(s, ALLOC_ALIGNMENT) - s;
-    int o = __SUM_OBJ_SIZE(slab_size, 1);
+    size_t s = __MAX_MEM_SIZE(slab_size, size);
+    size_t p = ALIGN_UP_POW2(s, ALLOC_ALIGNMENT) - s;
+    size_t o = __SUM_OBJ_SIZE(slab_size, 1);
     return size + p / o;
 }
 
-static inline int init_align_down(int size) {
+static inline size_t init_align_down(size_t size) {
     assert(IS_POWER_OF_2(ALLOC_ALIGNMENT));
-    int s = __INIT_MAX_MEM_SIZE(size);
-    int p = s - ALIGN_DOWN_POW2(s, ALLOC_ALIGNMENT);
-    int o = __INIT_SUM_OBJ_SIZE(1);
+    size_t s = __INIT_MAX_MEM_SIZE(size);
+    size_t p = s - ALIGN_DOWN_POW2(s, ALLOC_ALIGNMENT);
+    size_t o = __INIT_SUM_OBJ_SIZE(1);
     return size - p / o - (p % o ? 1 : 0);
 }
 
-static inline int init_size_align_up(int size) {
+static inline size_t init_size_align_up(size_t size) {
     assert(IS_POWER_OF_2(ALLOC_ALIGNMENT));
-    int s = __INIT_MAX_MEM_SIZE(size);
-    int p = ALIGN_UP_POW2(s, ALLOC_ALIGNMENT) - s;
-    int o = __INIT_SUM_OBJ_SIZE(1);
+    size_t s = __INIT_MAX_MEM_SIZE(size);
+    size_t p = ALIGN_UP_POW2(s, ALLOC_ALIGNMENT) - s;
+    size_t o = __INIT_SUM_OBJ_SIZE(1);
     return size + p / o;
 }
 #endif /* ALLOC_ALIGNMENT */
@@ -213,7 +213,7 @@ static inline int init_size_align_up(int size) {
 #endif
 
 static inline void __set_free_slab_area(SLAB_AREA area, struct slab_level_mgr* lmgr, int level) {
-    int slab_size     = slab_levels[level] + SLAB_HDR_SIZE;
+    size_t slab_size     = slab_levels[level] + SLAB_HDR_SIZE;
     lmgr->addr        = (void*)area->raw;
     lmgr->addr_top    = (void*)area->raw + (area->size * slab_size);
     lmgr->size       += area->size;