feat: kernel/libcpu: fit into ilp32d

8 files changed, 82 insertions, 82 deletions

diff --git a/src/ipc.c b/src/ipc.c
index 5ffcf017c2..3c6e82949b 100644
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -769,7 +769,7 @@ rt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg)
         rt_ubase_t value;
 
         /* get value */
-        value = (rt_ubase_t)arg;
+        value = (rt_uintptr_t)arg;
         level = rt_spin_lock_irqsave(&(sem->spinlock));
 
         /* resume all waiting thread */
@@ -787,7 +787,7 @@ rt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg)
         rt_ubase_t max_value;
         rt_bool_t need_schedule = RT_FALSE;
 
-        max_value = (rt_uint16_t)((rt_ubase_t)arg);
+        max_value = (rt_uint16_t)((rt_uintptr_t)arg);
         if (max_value > RT_SEM_VALUE_MAX || max_value < 1)
         {
             return -RT_EINVAL;
diff --git a/src/kservice.c b/src/kservice.c
index 915850e89d..5a59345b3e 100644
--- a/src/kservice.c
+++ b/src/kservice.c
@@ -93,8 +93,8 @@ rt_weak void rt_hw_cpu_shutdown(void)
 
 #ifdef __GNUC__
     #define RT_HW_BACKTRACE_FRAME_GET_SELF(frame) do {          \
-        (frame)->fp = (rt_base_t)__builtin_frame_address(0U);   \
-        (frame)->pc = ({__label__ pc; pc: (rt_base_t)&&pc;});   \
+        (frame)->fp = (rt_uintptr_t)__builtin_frame_address(0U);   \
+        (frame)->pc = ({__label__ pc; pc: (rt_uintptr_t)&&pc;});   \
     } while (0)
 
 #else
@@ -545,7 +545,7 @@ rt_err_t rt_backtrace_thread(rt_thread_t thread)
 
 static void cmd_backtrace(int argc, char** argv)
 {
-    rt_ubase_t pid;
+    rt_uintptr_t pid;
     char *end_ptr;
 
     if (argc != 2)
@@ -778,8 +778,8 @@ rt_inline void _slab_info(rt_size_t *total,
  */
 void rt_system_heap_init_generic(void *begin_addr, void *end_addr)
 {
-    rt_ubase_t begin_align = RT_ALIGN((rt_ubase_t)begin_addr, RT_ALIGN_SIZE);
-    rt_ubase_t end_align   = RT_ALIGN_DOWN((rt_ubase_t)end_addr, RT_ALIGN_SIZE);
+    rt_uintptr_t begin_align = RT_ALIGN((rt_uintptr_t)begin_addr, RT_ALIGN_SIZE);
+    rt_uintptr_t end_align   = RT_ALIGN_DOWN((rt_uintptr_t)end_addr, RT_ALIGN_SIZE);
 
     RT_ASSERT(end_align > begin_align);
 
@@ -988,17 +988,17 @@ rt_weak void *rt_malloc_align(rt_size_t size, rt_size_t align)
     if (ptr != RT_NULL)
     {
         /* the allocated memory block is aligned */
-        if (((rt_ubase_t)ptr & (align - 1)) == 0)
+        if (((rt_uintptr_t)ptr & (align - 1)) == 0)
         {
-            align_ptr = (void *)((rt_ubase_t)ptr + align);
+            align_ptr = (void *)((rt_uintptr_t)ptr + align);
         }
         else
         {
-            align_ptr = (void *)(((rt_ubase_t)ptr + (align - 1)) & ~(align - 1));
+            align_ptr = (void *)(((rt_uintptr_t)ptr + (align - 1)) & ~(align - 1));
         }
 
         /* set the pointer before alignment pointer to the real pointer */
-        *((rt_ubase_t *)((rt_ubase_t)align_ptr - sizeof(void *))) = (rt_ubase_t)ptr;
+        *((rt_uintptr_t *)((rt_uintptr_t)align_ptr - sizeof(void *))) = (rt_uintptr_t)ptr;
 
         ptr = align_ptr;
     }
@@ -1019,7 +1019,7 @@ rt_weak void rt_free_align(void *ptr)
 
     /* NULL check */
     if (ptr == RT_NULL) return;
-    real_ptr = (void *) * (rt_ubase_t *)((rt_ubase_t)ptr - sizeof(void *));
+    real_ptr = (void *) * (rt_uintptr_t *)((rt_uintptr_t)ptr - sizeof(void *));
     rt_free(real_ptr);
 }
 RTM_EXPORT(rt_free_align);
diff --git a/src/mem.c b/src/mem.c
index 64bf0fe018..26cba6d404 100644
--- a/src/mem.c
+++ b/src/mem.c
@@ -58,7 +58,7 @@
 
 struct rt_small_mem_item
 {
-    rt_ubase_t              pool_ptr;         /**< small memory object addr */
+    rt_uintptr_t            pool_ptr;         /**< small memory object addr */
     rt_size_t               next;             /**< next free item */
     rt_size_t               prev;             /**< prev free item */
 #ifdef RT_USING_MEMTRACE
@@ -82,19 +82,19 @@ struct rt_small_mem
     rt_size_t                   mem_size_aligned;       /**< aligned memory size */
 };
 
-#define MIN_SIZE (sizeof(rt_ubase_t) + sizeof(rt_size_t) + sizeof(rt_size_t))
+#define MIN_SIZE (sizeof(rt_uintptr_t) + sizeof(rt_size_t) + sizeof(rt_size_t))
 
 #define MEM_MASK ((~(rt_size_t)0) - 1)
 
-#define MEM_USED(_mem)       ((((rt_base_t)(_mem)) & MEM_MASK) | 0x1)
-#define MEM_FREED(_mem)      ((((rt_base_t)(_mem)) & MEM_MASK) | 0x0)
+#define MEM_USED(_mem)       ((((rt_uintptr_t)(_mem)) & MEM_MASK) | 0x1)
+#define MEM_FREED(_mem)      ((((rt_uintptr_t)(_mem)) & MEM_MASK) | 0x0)
 #define MEM_ISUSED(_mem)   \
-                      (((rt_base_t)(((struct rt_small_mem_item *)(_mem))->pool_ptr)) & (~MEM_MASK))
+                      (((rt_uintptr_t)(((struct rt_small_mem_item *)(_mem))->pool_ptr)) & (~MEM_MASK))
 #define MEM_POOL(_mem)     \
-    ((struct rt_small_mem *)(((rt_base_t)(((struct rt_small_mem_item *)(_mem))->pool_ptr)) & (MEM_MASK)))
+    ((struct rt_small_mem *)(((rt_uintptr_t)(((struct rt_small_mem_item *)(_mem))->pool_ptr)) & (MEM_MASK)))
 #define MEM_SIZE(_heap, _mem)      \
-    (((struct rt_small_mem_item *)(_mem))->next - ((rt_ubase_t)(_mem) - \
-    (rt_ubase_t)((_heap)->heap_ptr)) - RT_ALIGN(sizeof(struct rt_small_mem_item), RT_ALIGN_SIZE))
+    (((struct rt_small_mem_item *)(_mem))->next - ((rt_uintptr_t)(_mem) - \
+    (rt_uintptr_t)((_heap)->heap_ptr)) - RT_ALIGN(sizeof(struct rt_small_mem_item), RT_ALIGN_SIZE))
 
 #define MIN_SIZE_ALIGNED     RT_ALIGN(MIN_SIZE, RT_ALIGN_SIZE)
 #define SIZEOF_STRUCT_MEM    RT_ALIGN(sizeof(struct rt_small_mem_item), RT_ALIGN_SIZE)
@@ -173,12 +173,12 @@ rt_smem_t rt_smem_init(const char    *name,
 {
     struct rt_small_mem_item *mem;
     struct rt_small_mem *small_mem;
-    rt_ubase_t start_addr, begin_align, end_align, mem_size;
+    rt_uintptr_t start_addr, begin_align, end_align, mem_size;
 
-    small_mem = (struct rt_small_mem *)RT_ALIGN((rt_ubase_t)begin_addr, RT_ALIGN_SIZE);
-    start_addr = (rt_ubase_t)small_mem + sizeof(*small_mem);
-    begin_align = RT_ALIGN((rt_ubase_t)start_addr, RT_ALIGN_SIZE);
-    end_align   = RT_ALIGN_DOWN((rt_ubase_t)begin_addr + size, RT_ALIGN_SIZE);
+    small_mem = (struct rt_small_mem *)RT_ALIGN((rt_uintptr_t)begin_addr, RT_ALIGN_SIZE);
+    start_addr = (rt_uintptr_t)small_mem + sizeof(*small_mem);
+    begin_align = RT_ALIGN((rt_uintptr_t)start_addr, RT_ALIGN_SIZE);
+    end_align   = RT_ALIGN_DOWN((rt_uintptr_t)begin_addr + size, RT_ALIGN_SIZE);
 
     /* alignment addr */
     if ((end_align > (2 * SIZEOF_STRUCT_MEM)) &&
@@ -190,7 +190,7 @@ rt_smem_t rt_smem_init(const char    *name,
     else
     {
         rt_kprintf("mem init, error begin address 0x%x, and end address 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;
     }
@@ -207,7 +207,7 @@ rt_smem_t rt_smem_init(const char    *name,
     small_mem->heap_ptr = (rt_uint8_t *)begin_align;
 
     LOG_D("mem init, heap begin address 0x%x, size %d",
-            (rt_ubase_t)small_mem->heap_ptr, small_mem->mem_size_aligned);
+            (rt_uintptr_t)small_mem->heap_ptr, small_mem->mem_size_aligned);
 
     /* initialize the start of the heap */
     mem        = (struct rt_small_mem_item *)small_mem->heap_ptr;
@@ -372,13 +372,13 @@ void *rt_smem_alloc(rt_smem_t m, rt_size_t size)
 
                 RT_ASSERT(((small_mem->lfree == small_mem->heap_end) || (!MEM_ISUSED(small_mem->lfree))));
             }
-            RT_ASSERT((rt_ubase_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_ubase_t)small_mem->heap_end);
-            RT_ASSERT((rt_ubase_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0);
-            RT_ASSERT((((rt_ubase_t)mem) & (RT_ALIGN_SIZE - 1)) == 0);
+            RT_ASSERT((rt_uintptr_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_uintptr_t)small_mem->heap_end);
+            RT_ASSERT((rt_uintptr_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0);
+            RT_ASSERT((((rt_uintptr_t)mem) & (RT_ALIGN_SIZE - 1)) == 0);
 
             LOG_D("allocate memory at 0x%x, size: %d",
-                    (rt_ubase_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM),
-                    (rt_ubase_t)(mem->next - ((rt_uint8_t *)mem - small_mem->heap_ptr)));
+                    (rt_uintptr_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM),
+                    (rt_uintptr_t)(mem->next - ((rt_uint8_t *)mem - small_mem->heap_ptr)));
 
             /* return the memory data except mem struct */
             return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM;
@@ -431,7 +431,7 @@ void *rt_smem_realloc(rt_smem_t m, void *rmem, rt_size_t newsize)
     if (rmem == RT_NULL)
         return rt_smem_alloc(&small_mem->parent, newsize);
 
-    RT_ASSERT((((rt_ubase_t)rmem) & (RT_ALIGN_SIZE - 1)) == 0);
+    RT_ASSERT((((rt_uintptr_t)rmem) & (RT_ALIGN_SIZE - 1)) == 0);
     RT_ASSERT((rt_uint8_t *)rmem >= (rt_uint8_t *)small_mem->heap_ptr);
     RT_ASSERT((rt_uint8_t *)rmem < (rt_uint8_t *)small_mem->heap_end);
 
@@ -502,7 +502,7 @@ void rt_smem_free(void *rmem)
     if (rmem == RT_NULL)
         return;
 
-    RT_ASSERT((((rt_ubase_t)rmem) & (RT_ALIGN_SIZE - 1)) == 0);
+    RT_ASSERT((((rt_uintptr_t)rmem) & (RT_ALIGN_SIZE - 1)) == 0);
 
     /* Get the corresponding struct rt_small_mem_item ... */
     mem = (struct rt_small_mem_item *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM);
@@ -517,8 +517,8 @@ void rt_smem_free(void *rmem)
     RT_ASSERT(MEM_POOL(&small_mem->heap_ptr[mem->next]) == small_mem);
 
     LOG_D("release memory 0x%x, size: %d",
-            (rt_ubase_t)rmem,
-            (rt_ubase_t)(mem->next - ((rt_uint8_t *)mem - small_mem->heap_ptr)));
+            (rt_uintptr_t)rmem,
+            (rt_uintptr_t)(mem->next - ((rt_uint8_t *)mem - small_mem->heap_ptr)));
 
     /* ... and is now unused. */
     mem->pool_ptr = MEM_FREED(small_mem);
@@ -578,7 +578,7 @@ static int memcheck(int argc, char *argv[])
         /* check mem */
         for (mem = (struct rt_small_mem_item *)m->heap_ptr; mem != m->heap_end; mem = (struct rt_small_mem_item *)&m->heap_ptr[mem->next])
         {
-            position = (rt_ubase_t)mem - (rt_ubase_t)m->heap_ptr;
+            position = (rt_uintptr_t)mem - (rt_uintptr_t)m->heap_ptr;
             if (position < 0) goto __exit;
             if (position > (int)m->mem_size_aligned) goto __exit;
             if (MEM_POOL(mem) != m) goto __exit;
diff --git a/src/memheap.c b/src/memheap.c
index 4b09fead01..edc1eb2641 100644
--- a/src/memheap.c
+++ b/src/memheap.c
@@ -40,7 +40,7 @@
 #define RT_MEMHEAP_MINIALLOC    RT_ALIGN(12, RT_ALIGN_SIZE)
 
 #define RT_MEMHEAP_SIZE         RT_ALIGN(sizeof(struct rt_memheap_item), RT_ALIGN_SIZE)
-#define MEMITEM_SIZE(item)      ((rt_ubase_t)item->next - (rt_ubase_t)item - RT_MEMHEAP_SIZE)
+#define MEMITEM_SIZE(item)      ((rt_uintptr_t)item->next - (rt_uintptr_t)item - RT_MEMHEAP_SIZE)
 #define MEMITEM(ptr)            (struct rt_memheap_item*)((rt_uint8_t*)ptr - RT_MEMHEAP_SIZE)
 
 static void _remove_next_ptr(volatile struct rt_memheap_item *next_ptr)
@@ -899,10 +899,10 @@ static int memheapcheck(int argc, char *argv[])
                 break;
             }
             /* check next and prev */
-            if (!((rt_ubase_t)item->next <= (rt_ubase_t)((rt_ubase_t)heap->start_addr + heap->pool_size) &&
-                  (rt_ubase_t)item->prev >= (rt_ubase_t)heap->start_addr) &&
-                  (rt_ubase_t)item->next == RT_ALIGN((rt_ubase_t)item->next, RT_ALIGN_SIZE) &&
-                  (rt_ubase_t)item->prev == RT_ALIGN((rt_ubase_t)item->prev, RT_ALIGN_SIZE))
+            if (!((rt_uintptr_t)item->next <= (rt_uintptr_t)((rt_uintptr_t)heap->start_addr + heap->pool_size) &&
+                  (rt_uintptr_t)item->prev >= (rt_uintptr_t)heap->start_addr) &&
+                  (rt_uintptr_t)item->next == RT_ALIGN((rt_uintptr_t)item->next, RT_ALIGN_SIZE) &&
+                  (rt_uintptr_t)item->prev == RT_ALIGN((rt_uintptr_t)item->prev, RT_ALIGN_SIZE))
             {
                 has_bad = RT_TRUE;
                 break;
diff --git a/src/scheduler_comm.c b/src/scheduler_comm.c
index 4e5495e727..957f1a132e 100644
--- a/src/scheduler_comm.c
+++ b/src/scheduler_comm.c
@@ -244,13 +244,13 @@ void rt_scheduler_stack_check(struct rt_thread *thread)
 
 #ifndef RT_USING_HW_STACK_GUARD
 #ifdef ARCH_CPU_STACK_GROWS_UPWARD
-    if (*((rt_uint8_t *)((rt_ubase_t)thread->stack_addr + thread->stack_size - 1)) != '#' ||
+    if (*((rt_uint8_t *)((rt_uintptr_t)thread->stack_addr + thread->stack_size - 1)) != '#' ||
 #else
     if (*((rt_uint8_t *)thread->stack_addr) != '#' ||
 #endif /* ARCH_CPU_STACK_GROWS_UPWARD */
-        (rt_ubase_t)thread->sp <= (rt_ubase_t)thread->stack_addr ||
-        (rt_ubase_t)thread->sp >
-        (rt_ubase_t)thread->stack_addr + (rt_ubase_t)thread->stack_size)
+        (rt_uintptr_t)thread->sp <= (rt_uintptr_t)thread->stack_addr ||
+        (rt_uintptr_t)thread->sp >
+        (rt_uintptr_t)thread->stack_addr + (rt_uintptr_t)thread->stack_size)
     {
         rt_base_t dummy = 1;
 
@@ -261,9 +261,9 @@ void rt_scheduler_stack_check(struct rt_thread *thread)
 #endif /* RT_USING_HW_STACK_GUARD */
 #ifdef ARCH_CPU_STACK_GROWS_UPWARD
 #ifndef RT_USING_HW_STACK_GUARD
-    else if ((rt_ubase_t)thread->sp > ((rt_ubase_t)thread->stack_addr + thread->stack_size))
+    else if ((rt_uintptr_t)thread->sp > ((rt_uintptr_t)thread->stack_addr + thread->stack_size))
 #else
-    if ((rt_ubase_t)thread->sp > ((rt_ubase_t)thread->stack_addr + thread->stack_size))
+    if ((rt_uintptr_t)thread->sp > ((rt_uintptr_t)thread->stack_addr + thread->stack_size))
 #endif
     {
         LOG_W("warning: %s stack is close to the top of stack address.\n",
@@ -271,9 +271,9 @@ void rt_scheduler_stack_check(struct rt_thread *thread)
     }
 #else
 #ifndef RT_USING_HW_STACK_GUARD
-    else if ((rt_ubase_t)thread->sp <= ((rt_ubase_t)thread->stack_addr + 32))
+    else if ((rt_uintptr_t)thread->sp <= ((rt_uintptr_t)thread->stack_addr + 32))
 #else
-    if ((rt_ubase_t)thread->sp <= ((rt_ubase_t)thread->stack_addr + 32))
+    if ((rt_uintptr_t)thread->sp <= ((rt_uintptr_t)thread->stack_addr + 32))
 #endif
     {
         LOG_W("warning: %s stack is close to end of stack address.\n",
diff --git a/src/scheduler_up.c b/src/scheduler_up.c
index acc8ee8c95..d65870bbf2 100644
--- a/src/scheduler_up.c
+++ b/src/scheduler_up.c
@@ -181,7 +181,7 @@ void rt_system_scheduler_start(void)
 
     /* switch to new thread */
 
-    rt_hw_context_switch_to((rt_ubase_t)&to_thread->sp);
+    rt_hw_context_switch_to((rt_uintptr_t)&to_thread->sp);
 
     /* never come back */
 }
@@ -275,8 +275,8 @@ void rt_schedule(void)
 
                     RT_OBJECT_HOOK_CALL(rt_scheduler_switch_hook, (from_thread));
 
-                    rt_hw_context_switch((rt_ubase_t)&from_thread->sp,
-                            (rt_ubase_t)&to_thread->sp);
+                    rt_hw_context_switch((rt_uintptr_t)&from_thread->sp,
+                            (rt_uintptr_t)&to_thread->sp);
 
                     /* enable interrupt */
                     rt_hw_interrupt_enable(level);
@@ -306,8 +306,8 @@ void rt_schedule(void)
                 {
                     LOG_D("switch in interrupt");
 
-                    rt_hw_context_switch_interrupt((rt_ubase_t)&from_thread->sp,
-                            (rt_ubase_t)&to_thread->sp, from_thread, to_thread);
+                    rt_hw_context_switch_interrupt((rt_uintptr_t)&from_thread->sp,
+                            (rt_uintptr_t)&to_thread->sp, from_thread, to_thread);
                 }
             }
             else
diff --git a/src/signal.c b/src/signal.c
index 552d2a89cd..ace2dd1f4c 100644
--- a/src/signal.c
+++ b/src/signal.c
@@ -72,9 +72,9 @@ static void _signal_entry(void *parameter)
     RT_SCHED_CTX(tid).stat &= ~RT_THREAD_STAT_SIGNAL;
 
 #ifdef RT_USING_SMP
-    rt_hw_context_switch_to((rt_base_t)&parameter, tid);
+    rt_hw_context_switch_to((rt_uintptr_t)&parameter, tid);
 #else
-    rt_hw_context_switch_to((rt_ubase_t)&(tid->sp));
+    rt_hw_context_switch_to((rt_uintptr_t)&(tid->sp));
 #endif /* RT_USING_SMP */
 }
 
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)