[quality] remove void-arith

polarvid · polarvid · commit 93f16fd6f0bc · 2023-04-17T15:31:04.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_aspace.c b/components/mm/mm_aspace.c
@@ -172,9 +172,9 @@ int _varea_map_with_msg(rt_varea_t varea, struct rt_aspace_fault_msg *msg)
          * the page returned by handler is not checked
          * cause no much assumption can make on it
          */
-        void *store = msg->response.vaddr;
+        char *store = msg->response.vaddr;
         rt_size_t store_sz = msg->response.size;
-        if (msg->fault_vaddr + store_sz > varea->start + varea->size)
+        if ((char *)msg->fault_vaddr + store_sz > (char *)varea->start + varea->size)
         {
             LOG_W("%s: too much (0x%lx) of buffer on vaddr %p is provided",
                     __func__, store_sz, msg->fault_vaddr);
@@ -224,9 +224,9 @@ static int _do_prefetch(rt_aspace_t aspace, rt_varea_t varea, void *start,
     int err = RT_EOK;
 
     /* it's ensured by caller that start & size ara page-aligned */
-    void *end = start + size;
-    void *vaddr = start;
-    rt_size_t off = varea->offset + ((start - varea->start) >> ARCH_PAGE_SHIFT);
+    char *end = (char *)start + size;
+    char *vaddr = start;
+    rt_size_t off = varea->offset + ((vaddr - (char *)varea->start) >> ARCH_PAGE_SHIFT);
 
     while (vaddr != end)
     {
@@ -378,7 +378,7 @@ rt_varea_t _varea_create(void *start, rt_size_t size)
 }
 
 #define _IS_OVERFLOW(start, length) ((length) > (0ul - (uintptr_t)(start)))
-#define _IS_OVERSIZE(start, length, limit_s, limit_sz) (((length) + (rt_size_t)((start) - (limit_start))) > (limit_size))
+#define _IS_OVERSIZE(start, length, limit_s, limit_sz) (((length) + (rt_size_t)((char *)(start) - (char *)(limit_start))) > (limit_size))
 
 static inline int _not_in_range(void *start, rt_size_t length,
                                 void *limit_start, rt_size_t limit_size)
@@ -634,7 +634,7 @@ int rt_aspace_unmap(rt_aspace_t aspace, void *addr)
     if (_not_in_range(addr, 1, aspace->start, aspace->size))
     {
         LOG_I("%s: %lx not in range of aspace[%lx:%lx]", __func__, addr,
-              aspace->start, aspace->start + aspace->size);
+              aspace->start, (char *)aspace->start + aspace->size);
         return -RT_EINVAL;
     }
 
@@ -650,7 +650,7 @@ static inline void *_lower(void *a, void *b)
 
 static inline void *_align(void *va, rt_ubase_t align_mask)
 {
-    return (void *)((rt_ubase_t)(va + ~align_mask) & align_mask);
+    return (void *)((rt_ubase_t)((char *)va + ~align_mask) & align_mask);
 }
 
 static void *_ascending_search(rt_varea_t varea, rt_size_t req_size,
@@ -659,17 +659,17 @@ static void *_ascending_search(rt_varea_t varea, rt_size_t req_size,
     void *ret = RT_NULL;
     while (varea && varea->start < limit.end)
     {
-        void *candidate = varea->start + varea->size;
+        char *candidate = (char *)varea->start + varea->size;
         candidate = _align(candidate, align_mask);
 
-        if (candidate > limit.end || limit.end - candidate + 1 < req_size)
+        if (candidate > (char *)limit.end || (char *)limit.end - candidate + 1 < req_size)
             break;
 
         rt_varea_t nx_va = ASPACE_VAREA_NEXT(varea);
         if (nx_va)
         {
             rt_size_t gap_size =
-                _lower(limit.end, nx_va->start - 1) - candidate + 1;
+                (char *)_lower(limit.end, (char *)nx_va->start - 1) - candidate + 1;
             if (gap_size >= req_size)
             {
                 ret = candidate;
@@ -695,15 +695,15 @@ static void *_find_head_and_asc_search(rt_aspace_t aspace, rt_size_t req_size,
     rt_varea_t varea = _aspace_bst_search_exceed(aspace, limit.start);
     if (varea)
     {
-        void *candidate = _align(limit.start, align_mask);
-        rt_size_t gap_size = varea->start - candidate;
+        char *candidate = _align(limit.start, align_mask);
+        rt_size_t gap_size = (char *)varea->start - candidate;
         if (gap_size >= req_size)
         {
             rt_varea_t former = _aspace_bst_search(aspace, limit.start);
             if (former)
             {
-                candidate = _align(former->start + former->size, align_mask);
-                gap_size = varea->start - candidate;
+                candidate = _align((char *)former->start + former->size, align_mask);
+                gap_size = (char *)varea->start - candidate;
 
                 if (gap_size >= req_size)
                     va = candidate;
@@ -722,12 +722,12 @@ static void *_find_head_and_asc_search(rt_aspace_t aspace, rt_size_t req_size,
     }
     else
     {
-        void *candidate;
+        char *candidate;
         rt_size_t gap_size;
 
         candidate = limit.start;
         candidate = _align(candidate, align_mask);
-        gap_size = limit.end - candidate + 1;
+        gap_size = (char *)limit.end - candidate + 1;
 
         if (gap_size >= req_size)
             va = candidate;
@@ -742,7 +742,7 @@ static void *_find_free(rt_aspace_t aspace, void *prefer, rt_size_t req_size,
 {
     rt_varea_t varea = NULL;
     void *va = RT_NULL;
-    struct _mm_range limit = {limit_start, limit_start + limit_size - 1};
+    struct _mm_range limit = {limit_start, (char *)limit_start + limit_size - 1};
 
     rt_ubase_t align_mask = ~0ul;
     if (flags & MMF_REQUEST_ALIGN)
@@ -754,7 +754,7 @@ static void *_find_free(rt_aspace_t aspace, void *prefer, rt_size_t req_size,
     {
         /* if prefer and free, just return the prefer region */
         prefer = _align(prefer, align_mask);
-        struct _mm_range range = {prefer, prefer + req_size - 1};
+        struct _mm_range range = {prefer, (char *)prefer + req_size - 1};
         varea = _aspace_bst_search_overlap(aspace, range);
 
         if (!varea)
@@ -772,7 +772,7 @@ static void *_find_free(rt_aspace_t aspace, void *prefer, rt_size_t req_size,
             if (va == RT_NULL)
             {
                 /* rewind to first range */
-                limit.end = varea->start - 1;
+                limit.end = (char *)varea->start - 1;
                 va = _find_head_and_asc_search(aspace, req_size, align_mask,
                                                limit);
             }
@@ -790,7 +790,7 @@ int rt_aspace_load_page(rt_aspace_t aspace, void *addr, rt_size_t npage)
 {
     int err = RT_EOK;
     rt_varea_t varea;
-    void *end = addr + (npage << ARCH_PAGE_SHIFT);
+    char *end = (char *)addr + (npage << ARCH_PAGE_SHIFT);
 
     WR_LOCK(aspace);
     varea = _aspace_bst_search(aspace, addr);
@@ -801,7 +801,7 @@ int rt_aspace_load_page(rt_aspace_t aspace, void *addr, rt_size_t npage)
         LOG_W("%s: varea not exist", __func__);
         err = -RT_ENOENT;
     }
-    else if (addr >= end || (rt_size_t)addr & ARCH_PAGE_MASK ||
+    else if ((char *)addr >= end || (rt_size_t)addr & ARCH_PAGE_MASK ||
              _not_in_range(addr, npage << ARCH_PAGE_SHIFT, varea->start,
                            varea->size))
     {
@@ -930,12 +930,12 @@ static int _dump(rt_varea_t varea, void *arg)
 {
     if (varea->mem_obj && varea->mem_obj->get_name)
     {
-        rt_kprintf("[%p - %p] %s\n", varea->start, varea->start + varea->size,
+        rt_kprintf("[%p - %p] %s\n", varea->start, (char *)varea->start + varea->size,
                    varea->mem_obj->get_name(varea));
     }
     else
     {
-        rt_kprintf("[%p - %p] phy-map\n", varea->start, varea->start + varea->size);
+        rt_kprintf("[%p - %p] phy-map\n", varea->start, (char *)varea->start + varea->size);
         rt_kprintf("\t\\_ paddr = %p\n",  varea->offset << MM_PAGE_SHIFT);
     }
     return 0;
diff --git a/components/mm/mm_fault.c b/components/mm/mm_fault.c
@@ -104,7 +104,7 @@ int rt_aspace_fault_try_fix(struct rt_aspace_fault_msg *msg)
         if (varea)
         {
             void *pa = rt_hw_mmu_v2p(aspace, msg->fault_vaddr);
-            msg->off = (msg->fault_vaddr - varea->start) >> ARCH_PAGE_SHIFT;
+            msg->off = ((char *)msg->fault_vaddr - (char *)varea->start) >> ARCH_PAGE_SHIFT;
 
             /* permission checked by fault op */
             switch (msg->fault_op)
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
diff --git a/libcpu/aarch64/common/cpu.c b/libcpu/aarch64/common/cpu.c
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
`@@ -104,7 +104,7 @@ int rt_aspace_fault_try_fix(struct rt_aspace_fault_msg *msg)`
`104`	`104`	`if (varea)`
`105`	`105`	`{`
`106`	`106`	`void *pa = rt_hw_mmu_v2p(aspace, msg->fault_vaddr);`
`107`		`- msg->off = (msg->fault_vaddr - varea->start) >> ARCH_PAGE_SHIFT;`
	`107`	`+ msg->off = ((char )msg->fault_vaddr - (char )varea->start) >> ARCH_PAGE_SHIFT;`
`108`	`108`
`109`	`109`	`/* permission checked by fault op */`
`110`	`110`	`switch (msg->fault_op)`
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`