[quality] remove void-arith

polarvid · polarvid · commit 1f49de23dd1a · 2023-04-17T16:21:49.000+08:00
diff --git a/components/lwp/lwp.c b/components/lwp/lwp.c
@@ -1113,7 +1113,7 @@ static void _lwp_thread_entry(void *parameter)
     rt_hw_icache_invalidate_all();
 
 #ifdef ARCH_MM_MMU
-    arch_start_umode(lwp->args, lwp->text_entry, (void *)USER_STACK_VEND, tid->stack_addr + tid->stack_size);
+    arch_start_umode(lwp->args, lwp->text_entry, (void *)USER_STACK_VEND, (char *)tid->stack_addr + tid->stack_size);
 #else
     arch_start_umode(lwp->args, lwp->text_entry, lwp->data_entry, (void *)((uint32_t)lwp->data_entry + lwp->data_size));
 #endif /* ARCH_MM_MMU */
diff --git a/components/lwp/lwp_shm.c b/components/lwp/lwp_shm.c
@@ -63,7 +63,7 @@ static void on_shm_page_fault(struct rt_varea *varea, struct rt_aspace_fault_msg
 
     /* map all share page frames to user space in a time */
     void *page = (void *)shm->addr;
-    void *pg_paddr = page + PV_OFFSET;
+    void *pg_paddr = (char *)page + PV_OFFSET;
     err = rt_varea_map_range(varea, varea->start, pg_paddr, shm->size);
 
     if (err == RT_EOK)
diff --git a/components/lwp/lwp_syscall.c b/components/lwp/lwp_syscall.c
@@ -306,7 +306,7 @@ static void _crt_thread_entry(void *parameter)
     user_stack &= ~7; //align 8
 
 #ifdef ARCH_MM_MMU
-    arch_crt_start_umode(parameter, tid->user_entry, (void *)user_stack, tid->stack_addr + tid->stack_size);
+    arch_crt_start_umode(parameter, tid->user_entry, (void *)user_stack, (char *)tid->stack_addr + tid->stack_size);
 #else
     set_user_context((void*)user_stack);
     arch_start_umode(parameter, tid->user_entry, ((struct rt_lwp *)tid->lwp)->data_entry, (void*)user_stack);
@@ -2396,7 +2396,7 @@ sysret_t sys_execve(const char *path, char *const argv[], char *const envp[])
         arch_start_umode(lwp->args,
                 lwp->text_entry,
                 (void*)USER_STACK_VEND,
-                thread->stack_addr + thread->stack_size);
+                (char *)thread->stack_addr + thread->stack_size);
         /* never reach here */
     }
     return -EINVAL;
diff --git a/components/lwp/lwp_user_mm.c b/components/lwp/lwp_user_mm.c
@@ -123,7 +123,7 @@ static void _user_do_page_fault(struct rt_varea *varea,
 
     if (lwp_objs->source)
     {
-        void *paddr = rt_hw_mmu_v2p(lwp_objs->source, msg->fault_vaddr);
+        char *paddr = rt_hw_mmu_v2p(lwp_objs->source, msg->fault_vaddr);
         if (paddr != ARCH_MAP_FAILED)
         {
             void *vaddr;
@@ -221,9 +221,9 @@ int lwp_unmap_user(struct rt_lwp *lwp, void *va)
 static void _dup_varea(rt_varea_t varea, struct rt_lwp *src_lwp,
                        rt_aspace_t dst)
 {
-    void *vaddr = varea->start;
-    void *vend = vaddr + varea->size;
-    if (vaddr < (void *)USER_STACK_VSTART || vaddr >= (void *)USER_STACK_VEND)
+    char *vaddr = varea->start;
+    char *vend = vaddr + varea->size;
+    if (vaddr < (char *)USER_STACK_VSTART || vaddr >= (char *)USER_STACK_VEND)
     {
         while (vaddr != vend)
         {
@@ -431,7 +431,7 @@ void *lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa,
                        size_t map_size, int cached)
 {
     int err;
-    void *va;
+    char *va;
     size_t offset = 0;
 
     if (!map_size)
@@ -459,7 +459,7 @@ void *lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa,
     rt_size_t attr = cached ? MMU_MAP_U_RWCB : MMU_MAP_U_RW;
 
     err =
-        rt_aspace_map_phy(lwp->aspace, &hint, attr, MM_PA_TO_OFF(map_pa), &va);
+        rt_aspace_map_phy(lwp->aspace, &hint, attr, MM_PA_TO_OFF(map_pa), (void **)&va);
     if (err != RT_EOK)
     {
         va = RT_NULL;
diff --git a/components/mm/avl_adpt.c b/components/mm/avl_adpt.c
@@ -78,7 +78,7 @@ static struct rt_varea *search(struct util_avl_root *root,
     {
         rt_varea_t varea = VAREA_ENTRY(node);
         int cmp = compare(range.start, range.end, varea->start,
-                          varea->start + varea->size - 1);
+                          (char *)varea->start + varea->size - 1);
 
         if (cmp < 0)
         {
@@ -118,7 +118,7 @@ rt_varea_t _aspace_bst_search_exceed(struct rt_aspace *aspace, void *start)
         if (cmp < 0)
         {
             /* varae exceed start */
-            ptrdiff_t off = va_s - start;
+            ptrdiff_t off = (char *)va_s - (char *)start;
             if (off < min_off)
             {
                 min_off = off;
diff --git a/components/mm/ioremap.c b/components/mm/ioremap.c
@@ -33,12 +33,12 @@ enum ioremap_type
 
 static void *_ioremap_type(void *paddr, size_t size, enum ioremap_type type)
 {
-    void *v_addr = NULL;
+    char *v_addr = NULL;
     size_t attr;
     size_t lo_off;
     int err;
 
-    lo_off = (uintptr_t)paddr & ARCH_PAGE_MASK;
+    lo_off = (rt_ubase_t)paddr & ARCH_PAGE_MASK;
 
     struct rt_mm_va_hint hint = {
         .prefer = RT_NULL,
@@ -62,7 +62,7 @@ static void *_ioremap_type(void *paddr, size_t size, enum ioremap_type type)
     default:
         return v_addr;
     }
-    err = rt_aspace_map_phy(&rt_kernel_space, &hint, attr, MM_PA_TO_OFF(paddr), &v_addr);
+    err = rt_aspace_map_phy(&rt_kernel_space, &hint, attr, MM_PA_TO_OFF(paddr), (void **)&v_addr);
 
     if (err)
     {
diff --git a/components/mm/mm_object.c b/components/mm/mm_object.c
@@ -56,14 +56,14 @@ void rt_varea_pgmgr_pop_all(rt_varea_t varea)
 
 void rt_varea_pgmgr_pop(rt_varea_t varea, void *vaddr, rt_size_t size)
 {
-    void *vend = vaddr + size;
+    void *vend = (char *)vaddr + size;
     while (vaddr != vend)
     {
         rt_page_t page = rt_page_addr2page(vaddr);
         page->pre->next = page->next;
         page->next->pre = page->pre;
         rt_pages_free(vaddr, 0);
-        vaddr += ARCH_PAGE_SIZE;
+        vaddr = (char *)vaddr + ARCH_PAGE_SIZE;
     }
 }
 
diff --git a/components/mm/mm_page.c b/components/mm/mm_page.c
@@ -63,13 +63,13 @@ static void hint_free(rt_mm_va_hint_t hint)
 
 static void on_page_fault(struct rt_varea *varea, struct rt_aspace_fault_msg *msg)
 {
-    void *init_start = (void *)init_mpr_align_start;
-    void *init_end = (void *)init_mpr_align_end;
-    if (msg->fault_vaddr < init_end && msg->fault_vaddr >= init_start)
+    char *init_start = (void *)init_mpr_align_start;
+    char *init_end = (void *)init_mpr_align_end;
+    if ((char *)msg->fault_vaddr < init_end && (char *)msg->fault_vaddr >= init_start)
     {
-        rt_size_t offset = msg->fault_vaddr - init_start;
+        rt_size_t offset = (char *)msg->fault_vaddr - init_start;
         msg->response.status = MM_FAULT_STATUS_OK;
-        msg->response.vaddr = init_mpr_cont_start + offset;
+        msg->response.vaddr = (char *)init_mpr_cont_start + offset;
         msg->response.size = ARCH_PAGE_SIZE;
     }
     else
@@ -194,13 +194,13 @@ static void _trace_free(rt_page_t page, void *caller, size_t size_bits)
 
 static inline void *page_to_addr(rt_page_t page)
 {
-    return (void *)((page - page_start) << ARCH_PAGE_SHIFT) - PV_OFFSET;
+    return (void *)(((page - page_start) << ARCH_PAGE_SHIFT) - PV_OFFSET);
 }
 
 static inline rt_page_t addr_to_page(rt_page_t pg_start, void *addr)
 {
-    addr += PV_OFFSET;
-    return &pg_start[((uintptr_t)addr >> ARCH_PAGE_SHIFT)];
+    addr = (char *)addr + PV_OFFSET;
+    return &pg_start[((rt_ubase_t)addr >> ARCH_PAGE_SHIFT)];
 }
 
 #define FLOOR(val, align) (((rt_size_t)(val) + (align)-1) & ~((align)-1))
@@ -301,7 +301,7 @@ static void _pages_ref_inc(struct rt_page *p, rt_uint32_t size_bits)
     idx = idx & ~((1UL << size_bits) - 1);
 
     page_head = page_start + idx;
-    page_head = (void *)page_head + early_offset;
+    page_head = (void *)((char *)page_head + early_offset);
     page_head->ref_cnt++;
 }
 
@@ -324,7 +324,7 @@ static int _pages_free(rt_page_t page_list[], struct rt_page *p, rt_uint32_t siz
     struct rt_page *buddy;
 
     RT_ASSERT(p >= page_start);
-    RT_ASSERT((void *)p < rt_mpr_start + rt_mpr_size);
+    RT_ASSERT((char *)p < (char *)rt_mpr_start + rt_mpr_size);
     RT_ASSERT(rt_kmem_v2p(p));
     RT_ASSERT(p->ref_cnt > 0);
     RT_ASSERT(p->size_bits == ARCH_ADDRESS_WIDTH_BITS);
@@ -395,10 +395,10 @@ static struct rt_page *_pages_alloc(rt_page_t page_list[], rt_uint32_t size_bits
 
 static void _early_page_remove(rt_page_t page_list[], rt_page_t page, rt_uint32_t size_bits)
 {
-    rt_page_t page_cont = (void *)page + early_offset;
+    rt_page_t page_cont = (rt_page_t)((char *)page + early_offset);
     if (page_cont->pre)
     {
-        rt_page_t pre_cont = (void *)page_cont->pre + early_offset;
+        rt_page_t pre_cont = (rt_page_t)((char *)page_cont->pre + early_offset);
         pre_cont->next = page_cont->next;
     }
     else
@@ -408,7 +408,7 @@ static void _early_page_remove(rt_page_t page_list[], rt_page_t page, rt_uint32_
 
     if (page_cont->next)
     {
-        rt_page_t next_cont = (void *)page_cont->next + early_offset;
+        rt_page_t next_cont = (rt_page_t)((char *)page_cont->next + early_offset);
         next_cont->pre = page_cont->pre;
     }
 
@@ -418,13 +418,13 @@ static void _early_page_remove(rt_page_t page_list[], rt_page_t page, rt_uint32_
 static void _early_page_insert(rt_page_t page_list[], rt_page_t page, int size_bits)
 {
     RT_ASSERT((void *)page >= rt_mpr_start &&
-              (void *)page - rt_mpr_start < +rt_mpr_size);
-    rt_page_t page_cont = (void *)page + early_offset;
+              ((char *)page - (char *)rt_mpr_start) < rt_mpr_size);
+    rt_page_t page_cont = (rt_page_t)((char *)page + early_offset);
 
     page_cont->next = page_list[size_bits];
     if (page_cont->next)
     {
-        rt_page_t next_cont = (void *)page_cont->next + early_offset;
+        rt_page_t next_cont = (rt_page_t)((char *)page_cont->next + early_offset);
         next_cont->pre = page;
     }
     page_cont->pre = 0;
@@ -466,7 +466,7 @@ static struct rt_page *_early_pages_alloc(rt_page_t page_list[], rt_uint32_t siz
             level--;
         }
     }
-    rt_page_t page_cont = (void *)p + early_offset;
+    rt_page_t page_cont = (rt_page_t)((char *)p + early_offset);
     page_cont->size_bits = ARCH_ADDRESS_WIDTH_BITS;
     page_cont->ref_cnt = 1;
     return p;
@@ -723,7 +723,7 @@ static void _install_page(rt_page_t mpr_head, rt_region_t region, void *insert_h
 
         /* insert to list */
         rt_page_t *page_list = _get_page_list((void *)region.start);
-        insert(page_list, (void *)p - early_offset, size_bits - ARCH_PAGE_SHIFT);
+        insert(page_list, (rt_page_t)((char *)p - early_offset), size_bits - ARCH_PAGE_SHIFT);
         region.start += (1UL << size_bits);
     }
 }
@@ -778,9 +778,9 @@ void rt_page_init(rt_region_t reg)
     rt_size_t init_mpr_npage = init_mpr_size >> ARCH_PAGE_SHIFT;
 
     init_mpr_cont_start = (void *)reg.start;
-    void *init_mpr_cont_end = init_mpr_cont_start + init_mpr_size;
-    early_offset = init_mpr_cont_start - (void *)init_mpr_align_start;
-    rt_page_t mpr_cont = rt_mpr_start + early_offset;
+    rt_size_t init_mpr_cont_end = (rt_size_t)init_mpr_cont_start + init_mpr_size;
+    early_offset = (rt_size_t)init_mpr_cont_start - init_mpr_align_start;
+    rt_page_t mpr_cont = (void *)((char *)rt_mpr_start + early_offset);
 
     /* mark init mpr pages as illegal */
     rt_page_t head_cont = addr_to_page(mpr_cont, (void *)reg.start);
@@ -790,7 +790,7 @@ void rt_page_init(rt_region_t reg)
         iter->size_bits = ARCH_ADDRESS_WIDTH_BITS;
     }
 
-    reg.start = (rt_size_t)init_mpr_cont_end;
+    reg.start = init_mpr_cont_end;
     _install_page(mpr_cont, reg, _early_page_insert);
 
     pages_alloc_handler = _early_pages_alloc;
@@ -808,7 +808,7 @@ void rt_page_init(rt_region_t reg)
 static int _load_mpr_area(void *head, void *tail)
 {
     int err = 0;
-    void *iter = (void *)((uintptr_t)head & ~ARCH_PAGE_MASK);
+    char *iter = (char *)((rt_ubase_t)head & ~ARCH_PAGE_MASK);
     tail = (void *)FLOOR(tail, ARCH_PAGE_SIZE);
 
     while (iter != tail)
diff --git a/libcpu/aarch64/common/cpu.c b/libcpu/aarch64/common/cpu.c
@@ -132,7 +132,10 @@ static rt_uint64_t _read_be_number(void *start, int size)
 {
     rt_uint64_t buf = 0;
     for (; size > 0; size--)
-        buf = (buf << 32) | fdt32_to_cpu(*(uint32_t *)start++);
+    {
+        buf = (buf << 32) | fdt32_to_cpu(*(uint32_t *)start);
+        start = (uint32_t *)start + 1;
+    }
     return buf;
 }
 
diff --git a/libcpu/aarch64/common/mmu.c b/libcpu/aarch64/common/mmu.c

Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ static void _user_do_page_fault(struct rt_varea *varea,`
`123`	`123`
`124`	`124`	`if (lwp_objs->source)`
`125`	`125`	`{`
`126`		`- void *paddr = rt_hw_mmu_v2p(lwp_objs->source, msg->fault_vaddr);`
	`126`	`+ char *paddr = rt_hw_mmu_v2p(lwp_objs->source, msg->fault_vaddr);`
`127`	`127`	`if (paddr != ARCH_MAP_FAILED)`
`128`	`128`	`{`
`129`	`129`	`void *vaddr;`
`@@ -221,9 +221,9 @@ int lwp_unmap_user(struct rt_lwp lwp, void va)`
`221`	`221`	`static void _dup_varea(rt_varea_t varea, struct rt_lwp *src_lwp,`
`222`	`222`	`rt_aspace_t dst)`
`223`	`223`	`{`
`224`		`- void *vaddr = varea->start;`
`225`		`- void *vend = vaddr + varea->size;`
`226`		`- if (vaddr < (void )USER_STACK_VSTART \|\| vaddr >= (void )USER_STACK_VEND)`
	`224`	`+ char *vaddr = varea->start;`
	`225`	`+ char *vend = vaddr + varea->size;`
	`226`	`+ if (vaddr < (char )USER_STACK_VSTART \|\| vaddr >= (char )USER_STACK_VEND)`
`227`	`227`	`{`
`228`	`228`	`while (vaddr != vend)`
`229`	`229`	`{`
`@@ -431,7 +431,7 @@ void lwp_map_user_phy(struct rt_lwp lwp, void map_va, void map_pa,`
`431`	`431`	`size_t map_size, int cached)`
`432`	`432`	`{`
`433`	`433`	`int err;`
`434`		`- void *va;`
	`434`	`+ char *va;`
`435`	`435`	`size_t offset = 0;`
`436`	`436`
`437`	`437`	`if (!map_size)`
`@@ -459,7 +459,7 @@ void lwp_map_user_phy(struct rt_lwp lwp, void map_va, void map_pa,`
`459`	`459`	`rt_size_t attr = cached ? MMU_MAP_U_RWCB : MMU_MAP_U_RW;`
`460`	`460`
`461`	`461`	`err =`
`462`		`- rt_aspace_map_phy(lwp->aspace, &hint, attr, MM_PA_TO_OFF(map_pa), &va);`
	`462`	`+ rt_aspace_map_phy(lwp->aspace, &hint, attr, MM_PA_TO_OFF(map_pa), (void **)&va);`
`463`	`463`	`if (err != RT_EOK)`
`464`	`464`	`{`
`465`	`465`	`va = RT_NULL;`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ static struct rt_varea search(struct util_avl_root root,`
`78`	`78`	`{`
`79`	`79`	`rt_varea_t varea = VAREA_ENTRY(node);`
`80`	`80`	`int cmp = compare(range.start, range.end, varea->start,`
`81`		`- varea->start + varea->size - 1);`
	`81`	`+ (char *)varea->start + varea->size - 1);`
`82`	`82`
`83`	`83`	`if (cmp < 0)`
`84`	`84`	`{`
`@@ -118,7 +118,7 @@ rt_varea_t _aspace_bst_search_exceed(struct rt_aspace aspace, void start)`
`118`	`118`	`if (cmp < 0)`
`119`	`119`	`{`
`120`	`120`	`/* varae exceed start */`
`121`		`- ptrdiff_t off = va_s - start;`
	`121`	`+ ptrdiff_t off = (char )va_s - (char )start;`
`122`	`122`	`if (off < min_off)`
`123`	`123`	`{`
`124`	`124`	`min_off = off;`
Original file line number	Diff line number	Diff line change
`@@ -33,12 +33,12 @@ enum ioremap_type`
`33`	`33`
`34`	`34`	`static void _ioremap_type(void paddr, size_t size, enum ioremap_type type)`
`35`	`35`	`{`
`36`		`- void *v_addr = NULL;`
	`36`	`+ char *v_addr = NULL;`
`37`	`37`	`size_t attr;`
`38`	`38`	`size_t lo_off;`
`39`	`39`	`int err;`
`40`	`40`
`41`		`- lo_off = (uintptr_t)paddr & ARCH_PAGE_MASK;`
	`41`	`+ lo_off = (rt_ubase_t)paddr & ARCH_PAGE_MASK;`
`42`	`42`
`43`	`43`	`struct rt_mm_va_hint hint = {`
`44`	`44`	`.prefer = RT_NULL,`
`@@ -62,7 +62,7 @@ static void _ioremap_type(void paddr, size_t size, enum ioremap_type type)`
`62`	`62`	`default:`
`63`	`63`	`return v_addr;`
`64`	`64`	`}`
`65`		`- err = rt_aspace_map_phy(&rt_kernel_space, &hint, attr, MM_PA_TO_OFF(paddr), &v_addr);`
	`65`	`+ err = rt_aspace_map_phy(&rt_kernel_space, &hint, attr, MM_PA_TO_OFF(paddr), (void **)&v_addr);`
`66`	`66`
`67`	`67`	`if (err)`
`68`	`68`	`{`
Original file line number	Diff line number	Diff line change
`@@ -56,14 +56,14 @@ void rt_varea_pgmgr_pop_all(rt_varea_t varea)`
`56`	`56`
`57`	`57`	`void rt_varea_pgmgr_pop(rt_varea_t varea, void *vaddr, rt_size_t size)`
`58`	`58`	`{`
`59`		`- void *vend = vaddr + size;`
	`59`	`+ void vend = (char )vaddr + size;`
`60`	`60`	`while (vaddr != vend)`
`61`	`61`	`{`
`62`	`62`	`rt_page_t page = rt_page_addr2page(vaddr);`
`63`	`63`	`page->pre->next = page->next;`
`64`	`64`	`page->next->pre = page->pre;`
`65`	`65`	`rt_pages_free(vaddr, 0);`
`66`		`- vaddr += ARCH_PAGE_SIZE;`
	`66`	`+ vaddr = (char *)vaddr + ARCH_PAGE_SIZE;`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
Original file line number	Diff line number	Diff line change
`@@ -63,13 +63,13 @@ static void hint_free(rt_mm_va_hint_t hint)`
`63`	`63`
`64`	`64`	`static void on_page_fault(struct rt_varea varea, struct rt_aspace_fault_msg msg)`
`65`	`65`	`{`
`66`		`- void init_start = (void )init_mpr_align_start;`
`67`		`- void init_end = (void )init_mpr_align_end;`
`68`		`- if (msg->fault_vaddr < init_end && msg->fault_vaddr >= init_start)`
	`66`	`+ char init_start = (void )init_mpr_align_start;`
	`67`	`+ char init_end = (void )init_mpr_align_end;`
	`68`	`+ if ((char )msg->fault_vaddr < init_end && (char )msg->fault_vaddr >= init_start)`
`69`	`69`	`{`
`70`		`- rt_size_t offset = msg->fault_vaddr - init_start;`
	`70`	`+ rt_size_t offset = (char *)msg->fault_vaddr - init_start;`
`71`	`71`	`msg->response.status = MM_FAULT_STATUS_OK;`
`72`		`- msg->response.vaddr = init_mpr_cont_start + offset;`
	`72`	`+ msg->response.vaddr = (char *)init_mpr_cont_start + offset;`
`73`	`73`	`msg->response.size = ARCH_PAGE_SIZE;`
`74`	`74`	`}`
`75`	`75`	`else`
`@@ -194,13 +194,13 @@ static void _trace_free(rt_page_t page, void *caller, size_t size_bits)`
`194`	`194`
`195`	`195`	`static inline void *page_to_addr(rt_page_t page)`
`196`	`196`	`{`
`197`		`- return (void *)((page - page_start) << ARCH_PAGE_SHIFT) - PV_OFFSET;`
	`197`	`+ return (void *)(((page - page_start) << ARCH_PAGE_SHIFT) - PV_OFFSET);`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`static inline rt_page_t addr_to_page(rt_page_t pg_start, void *addr)`
`201`	`201`	`{`
`202`		`- addr += PV_OFFSET;`
`203`		`- return &pg_start[((uintptr_t)addr >> ARCH_PAGE_SHIFT)];`
	`202`	`+ addr = (char *)addr + PV_OFFSET;`
	`203`	`+ return &pg_start[((rt_ubase_t)addr >> ARCH_PAGE_SHIFT)];`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`#define FLOOR(val, align) (((rt_size_t)(val) + (align)-1) & ~((align)-1))`
`@@ -301,7 +301,7 @@ static void _pages_ref_inc(struct rt_page *p, rt_uint32_t size_bits)`
`301`	`301`	`idx = idx & ~((1UL << size_bits) - 1);`
`302`	`302`
`303`	`303`	`page_head = page_start + idx;`
`304`		`- page_head = (void *)page_head + early_offset;`
	`304`	`+ page_head = (void )((char )page_head + early_offset);`
`305`	`305`	`page_head->ref_cnt++;`
`306`	`306`	`}`
`307`	`307`
`@@ -324,7 +324,7 @@ static int _pages_free(rt_page_t page_list[], struct rt_page *p, rt_uint32_t siz`
`324`	`324`	`struct rt_page *buddy;`
`325`	`325`
`326`	`326`	`RT_ASSERT(p >= page_start);`
`327`		`- RT_ASSERT((void *)p < rt_mpr_start + rt_mpr_size);`
	`327`	`+ RT_ASSERT((char )p < (char )rt_mpr_start + rt_mpr_size);`
`328`	`328`	`RT_ASSERT(rt_kmem_v2p(p));`
`329`	`329`	`RT_ASSERT(p->ref_cnt > 0);`
`330`	`330`	`RT_ASSERT(p->size_bits == ARCH_ADDRESS_WIDTH_BITS);`
`@@ -395,10 +395,10 @@ static struct rt_page *_pages_alloc(rt_page_t page_list[], rt_uint32_t size_bits`
`395`	`395`
`396`	`396`	`static void _early_page_remove(rt_page_t page_list[], rt_page_t page, rt_uint32_t size_bits)`
`397`	`397`	`{`
`398`		`- rt_page_t page_cont = (void *)page + early_offset;`
	`398`	`+ rt_page_t page_cont = (rt_page_t)((char *)page + early_offset);`
`399`	`399`	`if (page_cont->pre)`
`400`	`400`	`{`
`401`		`- rt_page_t pre_cont = (void *)page_cont->pre + early_offset;`
	`401`	`+ rt_page_t pre_cont = (rt_page_t)((char *)page_cont->pre + early_offset);`
`402`	`402`	`pre_cont->next = page_cont->next;`
`403`	`403`	`}`
`404`	`404`	`else`
`@@ -408,7 +408,7 @@ static void _early_page_remove(rt_page_t page_list[], rt_page_t page, rt_uint32_`
`408`	`408`
`409`	`409`	`if (page_cont->next)`
`410`	`410`	`{`
`411`		`- rt_page_t next_cont = (void *)page_cont->next + early_offset;`
	`411`	`+ rt_page_t next_cont = (rt_page_t)((char *)page_cont->next + early_offset);`
`412`	`412`	`next_cont->pre = page_cont->pre;`
`413`	`413`	`}`
`414`	`414`
`@@ -418,13 +418,13 @@ static void _early_page_remove(rt_page_t page_list[], rt_page_t page, rt_uint32_`
`418`	`418`	`static void _early_page_insert(rt_page_t page_list[], rt_page_t page, int size_bits)`
`419`	`419`	`{`
`420`	`420`	`RT_ASSERT((void *)page >= rt_mpr_start &&`
`421`		`- (void *)page - rt_mpr_start < +rt_mpr_size);`
`422`		`- rt_page_t page_cont = (void *)page + early_offset;`
	`421`	`+ ((char )page - (char )rt_mpr_start) < rt_mpr_size);`
	`422`	`+ rt_page_t page_cont = (rt_page_t)((char *)page + early_offset);`
`423`	`423`
`424`	`424`	`page_cont->next = page_list[size_bits];`
`425`	`425`	`if (page_cont->next)`
`426`	`426`	`{`
`427`		`- rt_page_t next_cont = (void *)page_cont->next + early_offset;`
	`427`	`+ rt_page_t next_cont = (rt_page_t)((char *)page_cont->next + early_offset);`
`428`	`428`	`next_cont->pre = page;`
`429`	`429`	`}`
`430`	`430`	`page_cont->pre = 0;`
`@@ -466,7 +466,7 @@ static struct rt_page *_early_pages_alloc(rt_page_t page_list[], rt_uint32_t siz`
`466`	`466`	`level--;`
`467`	`467`	`}`
`468`	`468`	`}`
`469`		`- rt_page_t page_cont = (void *)p + early_offset;`
	`469`	`+ rt_page_t page_cont = (rt_page_t)((char *)p + early_offset);`
`470`	`470`	`page_cont->size_bits = ARCH_ADDRESS_WIDTH_BITS;`
`471`	`471`	`page_cont->ref_cnt = 1;`
`472`	`472`	`return p;`
`@@ -723,7 +723,7 @@ static void _install_page(rt_page_t mpr_head, rt_region_t region, void *insert_h`
`723`	`723`
`724`	`724`	`/* insert to list */`
`725`	`725`	`rt_page_t page_list = _get_page_list((void )region.start);`
`726`		`- insert(page_list, (void *)p - early_offset, size_bits - ARCH_PAGE_SHIFT);`
	`726`	`+ insert(page_list, (rt_page_t)((char *)p - early_offset), size_bits - ARCH_PAGE_SHIFT);`
`727`	`727`	`region.start += (1UL << size_bits);`
`728`	`728`	`}`
`729`	`729`	`}`
`@@ -778,9 +778,9 @@ void rt_page_init(rt_region_t reg)`
`778`	`778`	`rt_size_t init_mpr_npage = init_mpr_size >> ARCH_PAGE_SHIFT;`
`779`	`779`
`780`	`780`	`init_mpr_cont_start = (void *)reg.start;`
`781`		`- void *init_mpr_cont_end = init_mpr_cont_start + init_mpr_size;`
`782`		`- early_offset = init_mpr_cont_start - (void *)init_mpr_align_start;`
`783`		`- rt_page_t mpr_cont = rt_mpr_start + early_offset;`
	`781`	`+ rt_size_t init_mpr_cont_end = (rt_size_t)init_mpr_cont_start + init_mpr_size;`
	`782`	`+ early_offset = (rt_size_t)init_mpr_cont_start - init_mpr_align_start;`
	`783`	`+ rt_page_t mpr_cont = (void )((char )rt_mpr_start + early_offset);`
`784`	`784`
`785`	`785`	`/* mark init mpr pages as illegal */`
`786`	`786`	`rt_page_t head_cont = addr_to_page(mpr_cont, (void *)reg.start);`
`@@ -790,7 +790,7 @@ void rt_page_init(rt_region_t reg)`
`790`	`790`	`iter->size_bits = ARCH_ADDRESS_WIDTH_BITS;`
`791`	`791`	`}`
`792`	`792`
`793`		`- reg.start = (rt_size_t)init_mpr_cont_end;`
	`793`	`+ reg.start = init_mpr_cont_end;`
`794`	`794`	`_install_page(mpr_cont, reg, _early_page_insert);`
`795`	`795`
`796`	`796`	`pages_alloc_handler = _early_pages_alloc;`
`@@ -808,7 +808,7 @@ void rt_page_init(rt_region_t reg)`
`808`	`808`	`static int _load_mpr_area(void head, void tail)`
`809`	`809`	`{`
`810`	`810`	`int err = 0;`
`811`		`- void iter = (void )((uintptr_t)head & ~ARCH_PAGE_MASK);`
	`811`	`+ char iter = (char )((rt_ubase_t)head & ~ARCH_PAGE_MASK);`
`812`	`812`	`tail = (void *)FLOOR(tail, ARCH_PAGE_SIZE);`
`813`	`813`
`814`	`814`	`while (iter != tail)`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,10 @@ static rt_uint64_t _read_be_number(void *start, int size)`
`132`	`132`	`{`
`133`	`133`	`rt_uint64_t buf = 0;`
`134`	`134`	`for (; size > 0; size--)`
`135`		`- buf = (buf << 32) \| fdt32_to_cpu((uint32_t )start++);`
	`135`	`+ {`
	`136`	`+ buf = (buf << 32) \| fdt32_to_cpu((uint32_t )start);`
	`137`	`+ start = (uint32_t *)start + 1;`
	`138`	`+ }`
`136`	`139`	`return buf;`
`137`	`140`	`}`
`138`	`141`