feat: kernel/libcpu: fit into ilp32d

1 files changed, 25 insertions, 25 deletions

diff --git a/src/slab.c b/src/slab.c
index b1e2971b2e..456f0ec648 100644
--- a/src/slab.c
+++ b/src/slab.c
@@ -136,7 +136,7 @@
 #define PAGE_TYPE_LARGE     0x02
 
 #define btokup(addr)    \
-    (&slab->memusage[((rt_ubase_t)(addr) - slab->heap_start) >> RT_MM_PAGE_BITS])
+    (&slab->memusage[((rt_uintptr_t)(addr) - slab->heap_start) >> RT_MM_PAGE_BITS])
 
 /**
  * Base structure of slab memory object
@@ -194,8 +194,8 @@ struct rt_slab_page
 struct rt_slab
 {
     struct rt_memory            parent;                         /**< inherit from rt_memory */
-    rt_ubase_t                  heap_start;                     /**< memory start address */
-    rt_ubase_t                  heap_end;                       /**< memory end address */
+    rt_uintptr_t                heap_start;                     /**< memory start address */
+    rt_uintptr_t                heap_end;                       /**< memory end address */
     struct rt_slab_memusage    *memusage;
     struct rt_slab_zone        *zone_array[RT_SLAB_NZONES];     /* linked list of zones NFree > 0 */
     struct rt_slab_zone        *zone_free;                      /* whole zones that have become free */
@@ -261,7 +261,7 @@ void rt_slab_page_free(rt_slab_t m, void *addr, rt_size_t npages)
     struct rt_slab *slab = (struct rt_slab *)m;
 
     RT_ASSERT(addr != RT_NULL);
-    RT_ASSERT((rt_ubase_t)addr % RT_MM_PAGE_SIZE == 0);
+    RT_ASSERT((rt_uintptr_t)addr % RT_MM_PAGE_SIZE == 0);
     RT_ASSERT(npages != 0);
 
     n = (struct rt_slab_page *)addr;
@@ -324,18 +324,18 @@ static void rt_slab_page_init(struct rt_slab *slab, void *addr, rt_size_t npages
 rt_slab_t rt_slab_init(const char *name, void *begin_addr, rt_size_t size)
 {
     rt_uint32_t limsize, npages;
-    rt_ubase_t start_addr, begin_align, end_align;
+    rt_uintptr_t start_addr, begin_align, end_align;
     struct rt_slab *slab;
 
-    slab = (struct rt_slab *)RT_ALIGN((rt_ubase_t)begin_addr, RT_ALIGN_SIZE);
-    start_addr = (rt_ubase_t)slab + sizeof(*slab);
+    slab = (struct rt_slab *)RT_ALIGN((rt_uintptr_t)begin_addr, RT_ALIGN_SIZE);
+    start_addr = (rt_uintptr_t)slab + sizeof(*slab);
     /* align begin and end addr to page */
-    begin_align = RT_ALIGN((rt_ubase_t)start_addr, RT_MM_PAGE_SIZE);
-    end_align   = RT_ALIGN_DOWN((rt_ubase_t)begin_addr + size, RT_MM_PAGE_SIZE);
+    begin_align = RT_ALIGN((rt_uintptr_t)start_addr, RT_MM_PAGE_SIZE);
+    end_align   = RT_ALIGN_DOWN((rt_uintptr_t)begin_addr + size, RT_MM_PAGE_SIZE);
     if (begin_align >= end_align)
     {
         rt_kprintf("slab init errr. wrong address[0x%x - 0x%x]\n",
-                   (rt_ubase_t)begin_addr, (rt_ubase_t)begin_addr + size);
+                   (rt_uintptr_t)begin_addr, (rt_uintptr_t)begin_addr + size);
         return RT_NULL;
     }
 
@@ -378,7 +378,7 @@ rt_slab_t rt_slab_init(const char *name, void *begin_addr, rt_size_t size)
     slab->memusage = rt_slab_page_alloc((rt_slab_t)(&slab->parent), limsize / RT_MM_PAGE_SIZE);
 
     LOG_D("slab->memusage 0x%x, size 0x%x",
-          (rt_ubase_t)slab->memusage, limsize);
+          (rt_uintptr_t)slab->memusage, limsize);
     return &slab->parent;
 }
 RTM_EXPORT(rt_slab_init);
@@ -411,7 +411,7 @@ RTM_EXPORT(rt_slab_detach);
 rt_inline int zoneindex(rt_size_t *bytes)
 {
     /* unsigned for shift opt */
-    rt_ubase_t n = (rt_ubase_t)(*bytes);
+    rt_uintptr_t n = (rt_uintptr_t)(*bytes);
 
     if (n < 128)
     {
@@ -519,7 +519,7 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size)
         LOG_D("alloc a large memory 0x%x, page cnt %d, kup %d",
               size,
               size >> RT_MM_PAGE_BITS,
-              ((rt_ubase_t)chunk - slab->heap_start) >> RT_MM_PAGE_BITS);
+              ((rt_uintptr_t)chunk - slab->heap_start) >> RT_MM_PAGE_BITS);
         /* mem stat */
         slab->parent.used += size;
         if (slab->parent.used > slab->parent.max)
@@ -605,7 +605,7 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size)
             }
 
             LOG_D("alloc a new zone: 0x%x",
-                  (rt_ubase_t)z);
+                  (rt_uintptr_t)z);
 
             /* set message usage */
             for (off = 0, kup = btokup(z); off < slab->zone_page_cnt; off ++)
@@ -686,7 +686,7 @@ void *rt_slab_realloc(rt_slab_t m, void *ptr, rt_size_t size)
      * Get the original allocation's zone.  If the new request winds up
      * using the same chunk size we do not have to do anything.
      */
-    kup = btokup((rt_ubase_t)ptr & ~RT_MM_PAGE_MASK);
+    kup = btokup((rt_uintptr_t)ptr & ~RT_MM_PAGE_MASK);
     if (kup->type == PAGE_TYPE_LARGE)
     {
         rt_size_t osize;
@@ -701,7 +701,7 @@ void *rt_slab_realloc(rt_slab_t m, void *ptr, rt_size_t size)
     }
     else if (kup->type == PAGE_TYPE_SMALL)
     {
-        z = (struct rt_slab_zone *)(((rt_ubase_t)ptr & ~RT_MM_PAGE_MASK) -
+        z = (struct rt_slab_zone *)(((rt_uintptr_t)ptr & ~RT_MM_PAGE_MASK) -
                           kup->size * RT_MM_PAGE_SIZE);
         RT_ASSERT(z->z_magic == ZALLOC_SLAB_MAGIC);
 
@@ -749,19 +749,19 @@ void rt_slab_free(rt_slab_t m, void *ptr)
     /* get memory usage */
 #if (DBG_LVL == DBG_LOG)
     {
-        rt_ubase_t addr = ((rt_ubase_t)ptr & ~RT_MM_PAGE_MASK);
+        rt_uintptr_t addr = ((rt_uintptr_t)ptr & ~RT_MM_PAGE_MASK);
         LOG_D("free a memory 0x%x and align to 0x%x, kup index %d",
-              (rt_ubase_t)ptr,
-              (rt_ubase_t)addr,
-              ((rt_ubase_t)(addr) - slab->heap_start) >> RT_MM_PAGE_BITS);
+              (rt_uintptr_t)ptr,
+              (rt_uintptr_t)addr,
+              ((rt_uintptr_t)(addr) - slab->heap_start) >> RT_MM_PAGE_BITS);
     }
 #endif /* DBG_LVL == DBG_LOG */
 
-    kup = btokup((rt_ubase_t)ptr & ~RT_MM_PAGE_MASK);
+    kup = btokup((rt_uintptr_t)ptr & ~RT_MM_PAGE_MASK);
     /* release large allocation */
     if (kup->type == PAGE_TYPE_LARGE)
     {
-        rt_ubase_t size;
+        rt_uintptr_t size;
 
         /* clear page counter */
         size = kup->size;
@@ -770,7 +770,7 @@ void rt_slab_free(rt_slab_t m, void *ptr)
         slab->parent.used -= size * RT_MM_PAGE_SIZE;
 
         LOG_D("free large memory block 0x%x, page count %d",
-              (rt_ubase_t)ptr, size);
+              (rt_uintptr_t)ptr, size);
 
         /* free this page */
         rt_slab_page_free(m, ptr, size);
@@ -779,7 +779,7 @@ void rt_slab_free(rt_slab_t m, void *ptr)
     }
 
     /* zone case. get out zone. */
-    z = (struct rt_slab_zone *)(((rt_ubase_t)ptr & ~RT_MM_PAGE_MASK) -
+    z = (struct rt_slab_zone *)(((rt_uintptr_t)ptr & ~RT_MM_PAGE_MASK) -
                       kup->size * RT_MM_PAGE_SIZE);
     RT_ASSERT(z->z_magic == ZALLOC_SLAB_MAGIC);
 
@@ -811,7 +811,7 @@ void rt_slab_free(rt_slab_t m, void *ptr)
         struct rt_slab_zone **pz;
 
         LOG_D("free zone %#x, zoneindex %d",
-              (rt_ubase_t)z, z->z_zoneindex);
+              (rt_uintptr_t)z, z->z_zoneindex);
 
         /* remove zone from zone array list */
         for (pz = &slab->zone_array[z->z_zoneindex]; z != *pz; pz = &(*pz)->z_next)