Add -Wextra to CFLAGS too.

[simgrid.git] / src / xbt / mmalloc / mmalloc.c

diff --git a/src/xbt/mmalloc/mmalloc.c b/src/xbt/mmalloc/mmalloc.c
index 5b48368..6bf8eac 100644 (file)
--- a/src/xbt/mmalloc/mmalloc.c
+++ b/src/xbt/mmalloc/mmalloc.c
@@ -18,13 +18,13 @@
 
 static void initialize(xbt_mheap_t mdp);
 static void *register_morecore(xbt_mheap_t mdp, size_t size);
-static void *align(xbt_mheap_t mdp, size_t size);
+static void* mmalloc_aligned(xbt_mheap_t mdp, size_t size);
 
 /* Allocation aligned on block boundary.
  *
  * It never returns NULL, but dies verbosely on error.
  */
-static void *align(struct mdesc *mdp, size_t size)
+static void* mmalloc_aligned(struct mdesc* mdp, size_t size)
 {
   void *result;
   unsigned long int adj;
@@ -47,13 +47,11 @@ static void *align(struct mdesc *mdp, size_t size)
   return result;
 }
 
-/** Initialize heapinfo about the heapinfo pages :)
- *
- */
+/** Initialize heapinfo about the heapinfo pages :) */
 static void initialize_heapinfo_heapinfo(const s_xbt_mheap_t* mdp)
 {
   // Update heapinfo about the heapinfo pages (!):
-  xbt_assert((uintptr_t) mdp->heapinfo % BLOCKSIZE == 0);
+  mmalloc_assert((uintptr_t)mdp->heapinfo % BLOCKSIZE == 0, "Failed assert in initialize_heapinfo_heapinfo()");
   size_t block   = BLOCK(mdp->heapinfo);
   size_t nblocks = mdp->heapsize * sizeof(malloc_info) / BLOCKSIZE;
   // Mark them as free:
@@ -67,13 +65,12 @@ static void initialize_heapinfo_heapinfo(const s_xbt_mheap_t* mdp)
 }
 
 /* Finish the initialization of the mheap. If we want to inline it
- * properly, we need to make the align function publicly visible, too  */
+ * properly, we need to make the mmalloc_aligned function publicly visible, too  */
 static void initialize(xbt_mheap_t mdp)
 {
   // Update mdp meta-data:
   mdp->heapsize = HEAP / BLOCKSIZE;
-  mdp->heapinfo = (malloc_info *)
-    align(mdp, mdp->heapsize * sizeof(malloc_info));
+  mdp->heapinfo = (malloc_info*)mmalloc_aligned(mdp, mdp->heapsize * sizeof(malloc_info));
   mdp->heapbase = (void *) mdp->heapinfo;
   mdp->flags |= MMALLOC_INITIALIZED;
 
@@ -102,7 +99,7 @@ static inline void update_hook(void **a, size_t offset)
  * into the heap info table as necessary. */
 static void *register_morecore(struct mdesc *mdp, size_t size)
 {
-  void* result = align(mdp, size); // Never returns NULL
+  void* result = mmalloc_aligned(mdp, size); // Never returns NULL
 
   /* Check if we need to grow the info table (in a multiplicative manner)  */
   if ((size_t) BLOCK((char *) result + size) > mdp->heapsize) {
@@ -112,7 +109,7 @@ static void *register_morecore(struct mdesc *mdp, size_t size)
 
     /* Copy old info into new location */
     malloc_info* oldinfo = mdp->heapinfo;
-    malloc_info* newinfo = (malloc_info*)align(mdp, newsize * sizeof(malloc_info));
+    malloc_info* newinfo = (malloc_info*)mmalloc_aligned(mdp, newsize * sizeof(malloc_info));
     memcpy(newinfo, oldinfo, mdp->heapsize * sizeof(malloc_info));
 
     /* Initialize the new blockinfo : */
@@ -122,7 +119,7 @@ static void *register_morecore(struct mdesc *mdp, size_t size)
     /* Update the swag of busy blocks containing free fragments by applying the offset to all swag_hooks. Yeah. My hand is right in the fan and I still type */
     size_t offset=((char*)newinfo)-((char*)oldinfo);
 
-    for (int i = 1 /*first element of heapinfo describes the mdesc area*/; i < mdp->heaplimit; i++) {
+    for (size_t i = 1 /*first element of heapinfo describes the mdesc area*/; i < mdp->heaplimit; i++) {
       update_hook(&newinfo[i].freehook.next, offset);
       update_hook(&newinfo[i].freehook.prev, offset);
     }
@@ -135,7 +132,7 @@ static void *register_morecore(struct mdesc *mdp, size_t size)
 
     /* mark the space previously occupied by the block info as free by first marking it
      * as occupied in the regular way, and then freing it */
-    for (int it = 0; it < BLOCKIFY(mdp->heapsize * sizeof(malloc_info)); it++) {
+    for (size_t it = 0; it < BLOCKIFY(mdp->heapsize * sizeof(malloc_info)); it++) {
       newinfo[BLOCK(oldinfo)+it].type = MMALLOC_TYPE_UNFRAGMENTED;
       newinfo[BLOCK(oldinfo)+it].busy_block.ignore = 0;
     }
@@ -163,7 +160,7 @@ void *mmalloc(xbt_mheap_t mdp, size_t size) {
 
 static void mmalloc_mark_used(xbt_mheap_t mdp, size_t block, size_t nblocks, size_t requested_size)
 {
-  for (int it = 0; it < nblocks; it++) {
+  for (size_t it = 0; it < nblocks; it++) {
     mdp->heapinfo[block + it].type                 = MMALLOC_TYPE_UNFRAGMENTED;
     mdp->heapinfo[block + it].busy_block.busy_size = 0;
     mdp->heapinfo[block + it].busy_block.ignore    = 0;
@@ -217,8 +214,9 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size)
       for (candidate_frag=0;candidate_frag<(size_t) (BLOCKSIZE >> log);candidate_frag++)
         if (candidate_info->busy_frag.frag_size[candidate_frag] == -1)
           break;
-      xbt_assert(candidate_frag < (size_t) (BLOCKSIZE >> log),
-          "Block %zu was registered as containing free fragments of type %zu, but I can't find any",candidate_block,log);
+      mmalloc_assert(candidate_frag < (size_t)(BLOCKSIZE >> log),
+                     "Block %zu was registered as containing free fragments of type %zu, but I can't find any",
+                     candidate_block, log);
 
       result = (void*) (((char*)ADDRESS(candidate_block)) + (candidate_frag << log));