Remove redundant casts in GC_generic_or_special_malloc and similar

(refactoring)

* mallocx.c (GC_generic_or_special_malloc,
GC_generic_malloc_ignore_off_page): Remove redundant casts for
"lb" argument; remove redundant parentheses.
* fnlz_mlc.c (GC_finalized_malloc): Likewise.
* malloc.c (GC_generic_malloc, GC_malloc_uncollectable): Likewise.
* malloc.c (GC_malloc_uncollectable): Remove redundant cast of
returned value.
* mallocx.c (GC_malloc_ignore_off_page,
GC_malloc_atomic_ignore_off_page): Likewise.

3 files changed, 15 insertions, 16 deletions

diff --git a/fnlz_mlc.c b/fnlz_mlc.c
index 923810c8..23735bdb 100644
--- a/fnlz_mlc.c
+++ b/fnlz_mlc.c
@@ -98,7 +98,7 @@ GC_API void GC_CALL GC_register_disclaim_proc(int kind, GC_disclaim_proc proc,
         op = GC_finalized_objfreelist[lg];
         if (EXPECT(0 == op, FALSE)) {
             UNLOCK();
-            op = GC_generic_malloc((word)lb, GC_finalized_kind);
+            op = GC_generic_malloc(lb, GC_finalized_kind);
             if (NULL == op)
                 return NULL;
             /* GC_generic_malloc has extended the size map for us.      */
@@ -114,7 +114,7 @@ GC_API void GC_CALL GC_register_disclaim_proc(int kind, GC_disclaim_proc proc,
     } else {
         size_t op_sz;
 
-        op = GC_generic_malloc((word)lb, GC_finalized_kind);
+        op = GC_generic_malloc(lb, GC_finalized_kind);
         if (NULL == op)
             return NULL;
         op_sz = GC_size(op);
diff --git a/malloc.c b/malloc.c
index 11bc8ce8..836c916d 100644
--- a/malloc.c
+++ b/malloc.c
@@ -179,7 +179,7 @@ GC_API void * GC_CALL GC_generic_malloc(size_t lb, int k)
     GC_DBG_COLLECT_AT_MALLOC(lb);
     if (SMALL_OBJ(lb)) {
         LOCK();
-        result = GC_generic_malloc_inner((word)lb, k);
+        result = GC_generic_malloc_inner(lb, k);
         UNLOCK();
     } else {
         size_t lg;
@@ -312,15 +312,14 @@ GC_API void * GC_CALL GC_malloc_uncollectable(size_t lb)
             UNLOCK();
         } else {
             UNLOCK();
-            op = (ptr_t)GC_generic_malloc((word)lb, UNCOLLECTABLE);
+            op = GC_generic_malloc(lb, UNCOLLECTABLE);
             /* For small objects, the free lists are completely marked. */
         }
         GC_ASSERT(0 == op || GC_is_marked(op));
-        return((void *) op);
     } else {
         hdr * hhdr;
 
-        op = (ptr_t)GC_generic_malloc((word)lb, UNCOLLECTABLE);
+        op = GC_generic_malloc(lb, UNCOLLECTABLE);
         if (0 == op) return(0);
 
         GC_ASSERT(((word)op & (HBLKSIZE - 1)) == 0); /* large block */
@@ -337,8 +336,8 @@ GC_API void * GC_CALL GC_malloc_uncollectable(size_t lb)
 #       endif
         hhdr -> hb_n_marks = 1;
         UNLOCK();
-        return((void *) op);
     }
+    return op;
 }
 
 #ifdef REDIRECT_MALLOC
diff --git a/mallocx.c b/mallocx.c
index a2d9c70e..de9fd931 100644
--- a/mallocx.c
+++ b/mallocx.c
@@ -52,20 +52,20 @@ STATIC void * GC_generic_or_special_malloc(size_t lb, int knd)
     switch(knd) {
 #     ifdef STUBBORN_ALLOC
         case STUBBORN:
-            return(GC_malloc_stubborn((size_t)lb));
+            return GC_malloc_stubborn(lb);
 #     endif
         case PTRFREE:
-            return(GC_malloc_atomic((size_t)lb));
+            return GC_malloc_atomic(lb);
         case NORMAL:
-            return(GC_malloc((size_t)lb));
+            return GC_malloc(lb);
         case UNCOLLECTABLE:
-            return(GC_malloc_uncollectable((size_t)lb));
+            return GC_malloc_uncollectable(lb);
 #       ifdef ATOMIC_UNCOLLECTABLE
           case AUNCOLLECTABLE:
-            return(GC_malloc_atomic_uncollectable((size_t)lb));
+            return GC_malloc_atomic_uncollectable(lb);
 #       endif /* ATOMIC_UNCOLLECTABLE */
         default:
-            return(GC_generic_malloc(lb,knd));
+            return GC_generic_malloc(lb, knd);
     }
 }
 
@@ -177,7 +177,7 @@ GC_API void * GC_CALL GC_generic_malloc_ignore_off_page(size_t lb, int k)
     DCL_LOCK_STATE;
 
     if (SMALL_OBJ(lb))
-        return(GC_generic_malloc((word)lb, k));
+        return GC_generic_malloc(lb, k);
     lg = ROUNDED_UP_GRANULES(lb);
     lb_rounded = GRANULES_TO_BYTES(lg);
     if (lb_rounded < lb)
@@ -220,12 +220,12 @@ GC_API void * GC_CALL GC_generic_malloc_ignore_off_page(size_t lb, int k)
 
 GC_API void * GC_CALL GC_malloc_ignore_off_page(size_t lb)
 {
-    return((void *)GC_generic_malloc_ignore_off_page(lb, NORMAL));
+    return GC_generic_malloc_ignore_off_page(lb, NORMAL);
 }
 
 GC_API void * GC_CALL GC_malloc_atomic_ignore_off_page(size_t lb)
 {
-    return((void *)GC_generic_malloc_ignore_off_page(lb, PTRFREE));
+    return GC_generic_malloc_ignore_off_page(lb, PTRFREE);
 }
 
 /* Increment GC_bytes_allocd from code that doesn't have direct access  */