X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/2dab73b61a6ad4feb7d2d267bf5621c7b95926b3..bc603041d7ce7e32a2c888e7156e30035368b226:/src/mc/compare.cpp

diff --git a/src/mc/compare.cpp b/src/mc/compare.cpp
index dd6b7b9527..aec0a0cdf2 100644
--- a/src/mc/compare.cpp
+++ b/src/mc/compare.cpp
@@ -242,17 +242,17 @@ static bool mmalloc_heap_differ(StateComparator& state, const Snapshot& snapshot
       snapshot2.read<malloc_info*>(RemotePtr<malloc_info*>((std::uint64_t)heapinfo_address));
 
   while (i1 < state.heaplimit) {
-    const malloc_info* heapinfo1 =
-        (const malloc_info*)heap_region1->read(&heapinfo_temp1, &heapinfos1[i1], sizeof(malloc_info));
-    const malloc_info* heapinfo2 =
-        (const malloc_info*)heap_region2->read(&heapinfo_temp2, &heapinfos2[i1], sizeof(malloc_info));
+    const auto* heapinfo1 =
+        static_cast<malloc_info*>(heap_region1->read(&heapinfo_temp1, &heapinfos1[i1], sizeof(malloc_info)));
+    const auto* heapinfo2 =
+        static_cast<malloc_info*>(heap_region2->read(&heapinfo_temp2, &heapinfos2[i1], sizeof(malloc_info)));
 
     if (heapinfo1->type == MMALLOC_TYPE_FREE || heapinfo1->type == MMALLOC_TYPE_HEAPINFO) {      /* Free block */
       i1 ++;
       continue;
     }
 
-    xbt_assert(heapinfo1->type >= 0, "Unkown mmalloc block type: %d", heapinfo1->type);
+    xbt_assert(heapinfo1->type >= 0, "Unknown mmalloc block type: %d", heapinfo1->type);
 
     void* addr_block1 = ((void*)(((ADDR2UINT(i1)) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase));
 
@@ -295,8 +295,8 @@ static bool mmalloc_heap_differ(StateComparator& state, const Snapshot& snapshot
           continue;
         }
 
-        const malloc_info* heapinfo2b =
-            (const malloc_info*)heap_region2->read(&heapinfo_temp2b, &heapinfos2[i2], sizeof(malloc_info));
+        const auto* heapinfo2b =
+            static_cast<malloc_info*>(heap_region2->read(&heapinfo_temp2b, &heapinfos2[i2], sizeof(malloc_info)));
 
         if (heapinfo2b->type != MMALLOC_TYPE_UNFRAGMENTED) {
           i2++;
@@ -331,7 +331,7 @@ static bool mmalloc_heap_differ(StateComparator& state, const Snapshot& snapshot
         if (state.equals_to_<1>(i1, j1).valid_)
           continue;
 
-        void* addr_frag1 = (void*)((char*)addr_block1 + (j1 << heapinfo1->type));
+        void* addr_frag1 = (char*)addr_block1 + (j1 << heapinfo1->type);
 
         size_t i2 = 1;
         bool equal = false;
@@ -345,8 +345,8 @@ static bool mmalloc_heap_differ(StateComparator& state, const Snapshot& snapshot
         }
 
         while (i2 < state.heaplimit && not equal) {
-          const malloc_info* heapinfo2b =
-              (const malloc_info*)heap_region2->read(&heapinfo_temp2b, &heapinfos2[i2], sizeof(malloc_info));
+          const auto* heapinfo2b =
+              static_cast<malloc_info*>(heap_region2->read(&heapinfo_temp2b, &heapinfos2[i2], sizeof(malloc_info)));
 
           if (heapinfo2b->type == MMALLOC_TYPE_FREE || heapinfo2b->type == MMALLOC_TYPE_HEAPINFO) {
             i2 ++;
@@ -359,7 +359,7 @@ static bool mmalloc_heap_differ(StateComparator& state, const Snapshot& snapshot
             continue;
           }
 
-          xbt_assert(heapinfo2b->type >= 0, "Unkown mmalloc block type: %d", heapinfo2b->type);
+          xbt_assert(heapinfo2b->type >= 0, "Unknown mmalloc block type: %d", heapinfo2b->type);
 
           for (size_t j2 = 0; j2 < (size_t)(BLOCKSIZE >> heapinfo2b->type); j2++) {
             if (i2 == i1 && j2 == j1)
@@ -391,8 +391,8 @@ static bool mmalloc_heap_differ(StateComparator& state, const Snapshot& snapshot
 
   /* All blocks/fragments are equal to another block/fragment_ ? */
   for (size_t i = 1; i < state.heaplimit; i++) {
-    const malloc_info* heapinfo1 =
-        (const malloc_info*)heap_region1->read(&heapinfo_temp1, &heapinfos1[i], sizeof(malloc_info));
+    const auto* heapinfo1 =
+        static_cast<malloc_info*>(heap_region1->read(&heapinfo_temp1, &heapinfos1[i], sizeof(malloc_info)));
 
     if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED && i1 == state.heaplimit && heapinfo1->busy_block.busy_size > 0 &&
         not state.equals_to_<1>(i, 0).valid_) {
@@ -410,8 +410,8 @@ static bool mmalloc_heap_differ(StateComparator& state, const Snapshot& snapshot
   }
 
   for (size_t i = 1; i < state.heaplimit; i++) {
-    const malloc_info* heapinfo2 =
-        (const malloc_info*)heap_region2->read(&heapinfo_temp2, &heapinfos2[i], sizeof(malloc_info));
+    const auto* heapinfo2 =
+        static_cast<malloc_info*>(heap_region2->read(&heapinfo_temp2, &heapinfos2[i], sizeof(malloc_info)));
     if (heapinfo2->type == MMALLOC_TYPE_UNFRAGMENTED && i1 == state.heaplimit && heapinfo2->busy_block.busy_size > 0 &&
         not state.equals_to_<2>(i, 0).valid_) {
       XBT_DEBUG("Block %zu not found (size used = %zu)", i,
@@ -810,10 +810,10 @@ static bool heap_area_differ(StateComparator& state, const void* area1, const vo
   const Region* heap_region1 = MC_get_heap_region(snapshot1);
   const Region* heap_region2 = MC_get_heap_region(snapshot2);
 
-  const malloc_info* heapinfo1 =
-      (const malloc_info*)heap_region1->read(&heapinfo_temp1, &heapinfos1[block1], sizeof(malloc_info));
-  const malloc_info* heapinfo2 =
-      (const malloc_info*)heap_region2->read(&heapinfo_temp2, &heapinfos2[block2], sizeof(malloc_info));
+  const auto* heapinfo1 =
+      static_cast<malloc_info*>(heap_region1->read(&heapinfo_temp1, &heapinfos1[block1], sizeof(malloc_info)));
+  const auto* heapinfo2 =
+      static_cast<malloc_info*>(heap_region2->read(&heapinfo_temp2, &heapinfos2[block2], sizeof(malloc_info)));
 
   if ((heapinfo1->type == MMALLOC_TYPE_FREE || heapinfo1->type==MMALLOC_TYPE_HEAPINFO)
     && (heapinfo2->type == MMALLOC_TYPE_FREE || heapinfo2->type ==MMALLOC_TYPE_HEAPINFO)) {
@@ -873,12 +873,12 @@ static bool heap_area_differ(StateComparator& state, const void* area1, const vo
 
   } else if ((heapinfo1->type > 0) && (heapinfo2->type > 0)) {      /* Fragmented block */
     // Fragment number:
-    ssize_t frag1 = ((uintptr_t)(ADDR2UINT(area1) % (BLOCKSIZE))) >> heapinfo1->type;
-    ssize_t frag2 = ((uintptr_t)(ADDR2UINT(area2) % (BLOCKSIZE))) >> heapinfo2->type;
+    ssize_t frag1 = (ADDR2UINT(area1) % BLOCKSIZE) >> heapinfo1->type;
+    ssize_t frag2 = (ADDR2UINT(area2) % BLOCKSIZE) >> heapinfo2->type;
 
     // Process address of the fragment_:
-    void* real_addr_frag1 = (void*)((char*)real_addr_block1 + (frag1 << heapinfo1->type));
-    void* real_addr_frag2 = (void*)((char*)real_addr_block2 + (frag2 << heapinfo2->type));
+    void* real_addr_frag1 = (char*)real_addr_block1 + (frag1 << heapinfo1->type);
+    void* real_addr_frag2 = (char*)real_addr_block2 + (frag2 << heapinfo2->type);
 
     // Check the size of the fragments against the size of the type:
     if (type_size != -1) {
@@ -1015,7 +1015,6 @@ static bool areas_differ_with_type(simgrid::mc::StateComparator& state, const vo
   const simgrid::mc::Type* subtype;
   const simgrid::mc::Type* subsubtype;
   int elm_size;
-  int i;
 
   xbt_assert(type != nullptr);
   switch (type->type) {
@@ -1060,7 +1059,7 @@ static bool areas_differ_with_type(simgrid::mc::StateComparator& state, const vo
         default:
           return false;
       }
-      for (i = 0; i < type->element_count; i++) {
+      for (int i = 0; i < type->element_count; i++) {
         size_t off = i * elm_size;
         if (areas_differ_with_type(state, (const char*)real_area1 + off, snapshot1, region1,
                                    (const char*)real_area2 + off, snapshot2, region2, type->subtype, pointer_level))
@@ -1147,8 +1146,7 @@ static bool global_variables_differ(simgrid::mc::StateComparator& state,
     // If the variable is not in this object, skip it:
     // We do not expect to find a pointer to something which is not reachable
     // by the global variables.
-    if ((char *) current_var.address < (char *) object_info->start_rw
-        || (char *) current_var.address > (char *) object_info->end_rw)
+    if ((char*)current_var.address < object_info->start_rw || (char*)current_var.address > object_info->end_rw)
       continue;
 
     const simgrid::mc::Type* bvariable_type = current_var.type;