diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/ipc.c | 4 | ||||
| -rw-r--r-- | src/kservice.c | 20 | ||||
| -rw-r--r-- | src/mem.c | 50 | ||||
| -rw-r--r-- | src/memheap.c | 10 | ||||
| -rw-r--r-- | src/scheduler_comm.c | 16 | ||||
| -rw-r--r-- | src/scheduler_up.c | 10 | ||||
| -rw-r--r-- | src/signal.c | 4 | ||||
| -rw-r--r-- | src/slab.c | 50 |
8 files changed, 82 insertions, 82 deletions
@@ -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); @@ -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)¶meter, tid); + rt_hw_context_switch_to((rt_uintptr_t)¶meter, 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) |