[mc] Pass mc_object_info_t arguiments in many places intead of info->types

Preparation to remove get_type_description() calls which are very
inneficient.

diff --git a/include/xbt/mmalloc.h b/include/xbt/mmalloc.h
index 9708a76..1f37dda 100644 (file)
--- a/include/xbt/mmalloc.h
+++ b/include/xbt/mmalloc.h
@@ -20,6 +20,7 @@
 
 #include "xbt/dynar.h"
 #include "xbt/dict.h"
+#include "mc/datatypes.h"
 
 /* Datatype representing a separate heap. The whole point of the mmalloc module
  * is to allow several such heaps in the process. It thus works by redefining
@@ -38,6 +39,7 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size);
 
 /* Re-allocate the previously allocated block in void*, making the new block
    SIZE bytes long.  */
+
 XBT_PUBLIC( void ) *mrealloc(xbt_mheap_t md, void *ptr, size_t size);
 
 /* Free a block allocated by `mmalloc', `mrealloc' or `mcalloc'.  */
@@ -56,10 +58,10 @@ XBT_PUBLIC( xbt_mheap_t ) mmalloc_get_default_md(void);
 void mmalloc_set_current_heap(xbt_mheap_t new_heap);
 xbt_mheap_t mmalloc_get_current_heap(void);
 
-int mmalloc_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dict_t all_types, xbt_dict_t other_types);
+int mmalloc_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2, mc_object_info_t info, mc_object_info_t other_info);
 int mmalloc_linear_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2);
 int init_heap_information(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dynar_t to_ignore1, xbt_dynar_t to_ignore2);
-int compare_heap_area(void *area1, void* area2, xbt_dynar_t previous, xbt_dict_t all_types, xbt_dict_t other_types, char *type, int pointer_level);
+int compare_heap_area(void *area1, void* area2, xbt_dynar_t previous, mc_object_info_t info, mc_object_info_t other_info, char *type, int pointer_level);
 void reset_heap_information(void);
 int get_pointed_area_size(void *area, int heap);
 

diff --git a/src/include/mc/datatypes.h b/src/include/mc/datatypes.h
index 24c94e6..d9095c0 100644 (file)
--- a/src/include/mc/datatypes.h
+++ b/src/include/mc/datatypes.h
@@ -40,6 +40,10 @@ typedef struct s_stack_region{
 void heap_ignore_region_free(mc_heap_ignore_region_t r);
 void heap_ignore_region_free_voidp(void *r);
 
+/************ Object info *************/
+
+typedef struct s_mc_object_info s_mc_object_info_t, *mc_object_info_t;
+
 /************ DWARF structures *************/
 
 typedef int e_dw_type_type;
@@ -59,7 +63,7 @@ struct s_dw_type{
   dw_type_t subtype;
 };
 
-char* get_type_description(xbt_dict_t types, char *type_name);
+char* get_type_description(mc_object_info_t info, char *type_name);
 
 SG_END_DECL()
 #endif                          /* _MC_MC_H */

diff --git a/src/mc/mc_compare.c b/src/mc/mc_compare.c
index 919858f..b479c12 100644 (file)
--- a/src/mc/mc_compare.c
+++ b/src/mc/mc_compare.c
@@ -124,7 +124,7 @@ static void add_compared_pointers(void *p1, void *p2){
 
 }
 
-static int compare_areas_with_type(void *area1, void *area2, xbt_dict_t types, xbt_dict_t other_types, dw_type_t type, int region_size, int region_type, void *start_data, int pointer_level){
+static int compare_areas_with_type(void *area1, void *area2, mc_object_info_t info, mc_object_info_t other_info, dw_type_t type, int region_size, int region_type, void *start_data, int pointer_level){
 
   unsigned int cursor = 0;
   dw_type_t member, subtype, subsubtype;
@@ -140,7 +140,7 @@ static int compare_areas_with_type(void *area1, void *area2, xbt_dict_t types, x
   case DW_TAG_typedef:
   case DW_TAG_volatile_type:
   case DW_TAG_const_type:
-    return compare_areas_with_type(area1, area2, types, other_types, type->subtype, region_size, region_type, start_data, pointer_level);
+    return compare_areas_with_type(area1, area2, info, other_info, type->subtype, region_size, region_type, start_data, pointer_level);
     break;
   case DW_TAG_array_type:
     subtype = type->subtype;
@@ -151,7 +151,7 @@ static int compare_areas_with_type(void *area1, void *area2, xbt_dict_t types, x
     case DW_TAG_structure_type:
     case DW_TAG_union_type:
       if(subtype->byte_size == 0){ /*declaration of the type, need the complete description */
-          subtype = xbt_dict_get_or_null(other_types, get_type_description(other_types, subtype->name));
+          subtype = xbt_dict_get_or_null(other_info->types, get_type_description(other_info, subtype->name));
           switch_types = 1;
       }
       elm_size = subtype->byte_size;
@@ -161,7 +161,7 @@ static int compare_areas_with_type(void *area1, void *area2, xbt_dict_t types, x
     case DW_TAG_volatile_type:
       subsubtype = subtype->subtype;
       if(subsubtype->byte_size == 0){ /*declaration of the type, need the complete description */
-          subsubtype = xbt_dict_get_or_null(other_types, get_type_description(other_types, subsubtype->name));
+          subsubtype = xbt_dict_get_or_null(other_info->types, get_type_description(other_info, subsubtype->name));
           switch_types = 1;
       }
       elm_size = subsubtype->byte_size;
@@ -172,15 +172,15 @@ static int compare_areas_with_type(void *area1, void *area2, xbt_dict_t types, x
     }
     for(i=0; i<type->element_count; i++){
       if(switch_types)
-        res = compare_areas_with_type((char *)area1 + (i*elm_size), (char *)area2 + (i*elm_size), other_types, types, type->subtype, region_size, region_type, start_data, pointer_level);
+        res = compare_areas_with_type((char *)area1 + (i*elm_size), (char *)area2 + (i*elm_size), other_info, info, type->subtype, region_size, region_type, start_data, pointer_level);
       else
-        res = compare_areas_with_type((char *)area1 + (i*elm_size), (char *)area2 + (i*elm_size), types, other_types, type->subtype, region_size, region_type, start_data, pointer_level);
+        res = compare_areas_with_type((char *)area1 + (i*elm_size), (char *)area2 + (i*elm_size), info, other_info, type->subtype, region_size, region_type, start_data, pointer_level);
       if(res == 1)
         return res;
     }
     break;
   case DW_TAG_pointer_type:
-    if(type->dw_type_id && ((dw_type_t)xbt_dict_get_or_null(types, type->dw_type_id))->type == DW_TAG_subroutine_type){
+    if(type->dw_type_id && ((dw_type_t)xbt_dict_get_or_null(info->types, type->dw_type_id))->type == DW_TAG_subroutine_type){
       addr_pointed1 = *((void **)(area1)); 
       addr_pointed2 = *((void **)(area2));
       return (addr_pointed1 != addr_pointed2);
@@ -205,7 +205,7 @@ static int compare_areas_with_type(void *area1, void *area2, xbt_dict_t types, x
       if(addr_pointed1 > std_heap && (char *)addr_pointed1 < (char*) std_heap + STD_HEAP_SIZE){
         if(!(addr_pointed2 > std_heap && (char *)addr_pointed2 < (char*) std_heap + STD_HEAP_SIZE))
           xbt_die("Die");
-        return compare_heap_area(addr_pointed1, addr_pointed2, NULL, types, other_types, type->dw_type_id, pointer_level); 
+        return compare_heap_area(addr_pointed1, addr_pointed2, NULL, info, other_info, type->dw_type_id, pointer_level);
       }
 
       // The pointers are both in the current object R/W segment:
@@ -215,7 +215,7 @@ static int compare_areas_with_type(void *area1, void *area2, xbt_dict_t types, x
         if(type->dw_type_id == NULL)
           return  (addr_pointed1 != addr_pointed2);
         else
-          return  compare_areas_with_type(addr_pointed1, addr_pointed2, types, other_types, type->subtype, region_size, region_type, start_data, pointer_level);
+          return  compare_areas_with_type(addr_pointed1, addr_pointed2, info, other_info, type->subtype, region_size, region_type, start_data, pointer_level);
       }
 
       else{
@@ -226,7 +226,7 @@ static int compare_areas_with_type(void *area1, void *area2, xbt_dict_t types, x
   case DW_TAG_structure_type:
     xbt_dynar_foreach(type->members, cursor, member){
       XBT_DEBUG("Compare member %s", member->name);
-      res = compare_areas_with_type((char *)area1 + member->offset, (char *)area2 + member->offset, types, other_types, member->subtype, region_size, region_type, start_data, pointer_level);
+      res = compare_areas_with_type((char *)area1 + member->offset, (char *)area2 + member->offset, info, other_info, member->subtype, region_size, region_type, start_data, pointer_level);
       if(res == 1)
         return res;
     }
@@ -252,7 +252,6 @@ static int compare_global_variables(int region_type, mc_mem_region_t r1, mc_mem_
   }
 
   xbt_dynar_t variables;
-  xbt_dict_t types, other_types;
   int res;
   unsigned int cursor = 0;
   dw_variable_t current_var;
@@ -273,8 +272,6 @@ static int compare_global_variables(int region_type, mc_mem_region_t r1, mc_mem_
     start_data = start_data_libsimgrid;
   }
   variables = object_info->global_variables;
-  types = object_info->types;
-  other_types = other_object_info->types;
 
   xbt_dynar_foreach(variables, cursor, current_var){
 
@@ -287,8 +284,8 @@ static int compare_global_variables(int region_type, mc_mem_region_t r1, mc_mem_
 
     offset = (char *)current_var->address.address - (char *)object_info->start_rw;
 
-    dw_type_t bvariable_type = xbt_dict_get_or_null(types, current_var->type_origin);
-    res = compare_areas_with_type((char *)r1->data + offset, (char *)r2->data + offset, types, other_types, bvariable_type, r1->size, region_type, start_data, 0);
+    dw_type_t bvariable_type = xbt_dict_get_or_null(object_info->types, current_var->type_origin);
+    res = compare_areas_with_type((char *)r1->data + offset, (char *)r2->data + offset, object_info, other_object_info, bvariable_type, r1->size, region_type, start_data, 0);
     if(res == 1){
       XBT_VERB("Global variable %s (%p - %p) is different between snapshots", current_var->name, (char *)r1->data + offset, (char *)r2->data + offset);
       xbt_dynar_free(&compared_pointers);
@@ -340,10 +337,10 @@ static int compare_local_variables(mc_snapshot_stack_t stack1, mc_snapshot_stack
 
       if(current_var1->region == 1) {
         dw_type_t subtype = xbt_dict_get_or_null(mc_libsimgrid_info->types, current_var1->type);
-        res = compare_areas_with_type( (char *)heap1 + offset1, (char *)heap2 + offset2, mc_libsimgrid_info->types, mc_binary_info->types, subtype, 0, 1, start_data_libsimgrid, 0);
+        res = compare_areas_with_type( (char *)heap1 + offset1, (char *)heap2 + offset2, mc_libsimgrid_info, mc_binary_info, subtype, 0, 1, start_data_libsimgrid, 0);
       } else {
         dw_type_t subtype = xbt_dict_get_or_null(mc_binary_info->types, current_var1->type);
-        res = compare_areas_with_type( (char *)heap1 + offset1, (char *)heap2 + offset2, mc_binary_info->types, mc_libsimgrid_info->types, subtype, 0, 2, start_data_binary, 0);
+        res = compare_areas_with_type( (char *)heap1 + offset1, (char *)heap2 + offset2, mc_binary_info, mc_libsimgrid_info, subtype, 0, 2, start_data_binary, 0);
       }
       if(res == 1){
         XBT_VERB("Local variable %s (%p - %p) in frame %s  is different between snapshots", current_var1->name,(char *)heap1 + offset1, (char *)heap2 + offset2, current_var1->frame);
@@ -611,8 +608,8 @@ int snapshot_compare(void *state1, void *state2){
   /* Compare heap */
     if(mmalloc_compare_heap((xbt_mheap_t)s1->regions[0]->data,
                             (xbt_mheap_t)s2->regions[0]->data,
-                            mc_libsimgrid_info->types,
-                            mc_binary_info->types) > 0){
+                            mc_libsimgrid_info,
+                            mc_binary_info) > 0){
 
     #ifdef MC_DEBUG
       xbt_os_walltimer_stop(timer);

diff --git a/src/mc/mc_private.h b/src/mc/mc_private.h
index a7398cb..45e6bc8 100644 (file)
--- a/src/mc/mc_private.h
+++ b/src/mc/mc_private.h
@@ -322,7 +322,7 @@ void MC_dump_stack_liveness(xbt_fifo_t stack);
 
 /********************************** Variables with DWARF **********************************/
 
-typedef struct s_mc_object_info {
+struct s_mc_object_info {
   char* file_name;
   char *start_exec, *end_exec; // Executable segment
   char *start_rw, *end_rw; // Read-write segment
@@ -331,7 +331,7 @@ typedef struct s_mc_object_info {
   xbt_dynar_t global_variables; // xbt_dynar_t<dw_variable_t>
   xbt_dict_t types; // xbt_dict_t<origin as hexadecimal string, dw_type_t>
   xbt_dict_t types_by_name; // xbt_dict_t<name, dw_type_t> (full defined type only)
-} s_mc_object_info_t, *mc_object_info_t;
+};
 
 mc_object_info_t MC_new_object_info(void);
 mc_object_info_t MC_find_object_info(memory_map_t maps, char* name);

diff --git a/src/xbt/mmalloc/mm_diff.c b/src/xbt/mmalloc/mm_diff.c
index c286c5c..bc2da3a 100644 (file)
--- a/src/xbt/mmalloc/mm_diff.c
+++ b/src/xbt/mmalloc/mm_diff.c
@@ -11,6 +11,7 @@
 #include "mc/mc.h"
 #include "xbt/mmalloc.h"
 #include "mc/datatypes.h"
+#include "mc/mc_private.h"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mm_diff, xbt,
                                 "Logging specific to mm_diff in mmalloc");
@@ -408,7 +409,7 @@ void reset_heap_information(){
 
 }
 
-int mmalloc_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dict_t all_types, xbt_dict_t other_types){
+int mmalloc_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2, mc_object_info_t info, mc_object_info_t other_info){
 
   if(heap1 == NULL && heap2 == NULL){
     XBT_DEBUG("Malloc descriptors null");
@@ -464,7 +465,7 @@ int mmalloc_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dict_t all_ty
 
           addr_block2 = ((void*) (((ADDR2UINT(i1)) - 1) * BLOCKSIZE + (char*)((xbt_mheap_t)s_heap)->heapbase));
         
-          res_compare = compare_heap_area(addr_block1, addr_block2, NULL, all_types, other_types, NULL, 0);
+          res_compare = compare_heap_area(addr_block1, addr_block2, NULL, info, other_info, NULL, 0);
         
           if(res_compare != 1){
             for(k=1; k < heapinfo2[i1].busy_block.size; k++)
@@ -500,7 +501,7 @@ int mmalloc_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dict_t all_ty
           continue;
         }
           
-        res_compare = compare_heap_area(addr_block1, addr_block2, NULL, all_types, other_types, NULL, 0);
+        res_compare = compare_heap_area(addr_block1, addr_block2, NULL, info, other_info, NULL, 0);
         
         if(res_compare != 1 ){
           for(k=1; k < heapinfo2[i2].busy_block.size; k++)
@@ -547,7 +548,7 @@ int mmalloc_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dict_t all_ty
             addr_block2 = ((void*) (((ADDR2UINT(i1)) - 1) * BLOCKSIZE + (char*)((xbt_mheap_t)s_heap)->heapbase));
             addr_frag2 = (void*) ((char *)addr_block2 + (j1 << ((xbt_mheap_t)s_heap)->heapinfo[i1].type));
 
-            res_compare = compare_heap_area(addr_frag1, addr_frag2, NULL, all_types, other_types, NULL, 0);
+            res_compare = compare_heap_area(addr_frag1, addr_frag2, NULL, info, other_info, NULL, 0);
 
             if(res_compare !=  1)
               equal = 1;
@@ -576,7 +577,7 @@ int mmalloc_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dict_t all_ty
             addr_block2 = ((void*) (((ADDR2UINT(i2)) - 1) * BLOCKSIZE + (char*)((xbt_mheap_t)s_heap)->heapbase));
             addr_frag2 = (void*) ((char *)addr_block2 + (j2 <<((xbt_mheap_t)s_heap)->heapinfo[i2].type));
 
-            res_compare = compare_heap_area(addr_frag1, addr_frag2, NULL, all_types, other_types, NULL, 0);
+            res_compare = compare_heap_area(addr_frag1, addr_frag2, NULL, info, other_info, NULL, 0);
             
             if(res_compare != 1){
               equal = 1;
@@ -700,7 +701,7 @@ int mmalloc_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dict_t all_ty
   return ((nb_diff1 > 0) || (nb_diff2 > 0));
 }
 
-static int compare_heap_area_without_type(void *real_area1, void *real_area2, void *area1, void *area2, xbt_dynar_t previous, xbt_dict_t all_types, xbt_dict_t other_types, int size, int check_ignore){
+static int compare_heap_area_without_type(void *real_area1, void *real_area2, void *area1, void *area2, xbt_dynar_t previous, mc_object_info_t info, mc_object_info_t other_info, int size, int check_ignore){
 
   int i = 0;
   void *addr_pointed1, *addr_pointed2;
@@ -735,7 +736,7 @@ static int compare_heap_area_without_type(void *real_area1, void *real_area2, vo
         continue;
       }else if((addr_pointed1 > s_heap) && ((char *)addr_pointed1 < (char *)s_heap + STD_HEAP_SIZE) 
                && (addr_pointed2 > s_heap) && ((char *)addr_pointed2 < (char *)s_heap + STD_HEAP_SIZE)){
-        res_compare = compare_heap_area(addr_pointed1, addr_pointed2, previous, all_types, other_types, NULL, 0); 
+        res_compare = compare_heap_area(addr_pointed1, addr_pointed2, previous, info, other_info, NULL, 0);
         if(res_compare == 1){
           return res_compare;
         }
@@ -757,7 +758,7 @@ static int compare_heap_area_without_type(void *real_area1, void *real_area2, vo
 
 // area_size is either a byte_size or an elements_count?&
 static int compare_heap_area_with_type(void *real_area1, void *real_area2, void *area1, void *area2, 
-                                       xbt_dynar_t previous, xbt_dict_t all_types, xbt_dict_t other_types, char *type_id, 
+                                       xbt_dynar_t previous, mc_object_info_t info, mc_object_info_t other_info, char *type_id,
                                        int area_size, int check_ignore, int pointer_level){
 
   if(is_stack(real_area1) && is_stack(real_area2))
@@ -769,7 +770,7 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
     return 0;
   }
   
-  dw_type_t type = xbt_dict_get_or_null(all_types, type_id);
+  dw_type_t type = xbt_dict_get_or_null(info->types, type_id);
   dw_type_t subtype, subsubtype;
   int res, elm_size, i, switch_types = 0;
   unsigned int cursor = 0;
@@ -801,10 +802,10 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
   case DW_TAG_typedef:
   case DW_TAG_const_type:
   case DW_TAG_volatile_type:
-    return compare_heap_area_with_type(real_area1, real_area2, area1, area2, previous, all_types, other_types, type->dw_type_id, area_size, check_ignore, pointer_level);
+    return compare_heap_area_with_type(real_area1, real_area2, area1, area2, previous, info, other_info, type->dw_type_id, area_size, check_ignore, pointer_level);
     break;
   case DW_TAG_array_type:
-    subtype = xbt_dict_get_or_null(all_types, type->dw_type_id);
+    subtype = xbt_dict_get_or_null(info->types, type->dw_type_id);
     switch(subtype->type){
     case DW_TAG_base_type:
     case DW_TAG_enumeration_type:
@@ -812,11 +813,10 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
     case DW_TAG_structure_type:
     case DW_TAG_union_type:
       if(subtype->byte_size == 0){ /*declaration of the type, need the complete description */
-        type_desc = get_type_description(all_types, subtype->name);
-        if(type_desc){
-          subtype = xbt_dict_get_or_null(all_types, type_desc);
+        if(subtype->subtype && subtype->subtype->byte_size!=0){
+          subtype = subtype->subtype;
         }else{
-          subtype = xbt_dict_get_or_null(other_types, get_type_description(other_types, subtype->name));
+          subtype = xbt_dict_get_or_null(other_info->types, get_type_description(other_info, subtype->name));
           switch_types = 1;
         }
       }
@@ -826,13 +826,13 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
     case DW_TAG_const_type:
     case DW_TAG_typedef:
     case DW_TAG_volatile_type:
-      subsubtype = xbt_dict_get_or_null(all_types, subtype->dw_type_id);
+      subsubtype = xbt_dict_get_or_null(info->types, subtype->dw_type_id);
       if(subsubtype->byte_size == 0){ /*declaration of the type, need the complete description */
-        type_desc = get_type_description(all_types, subsubtype->name);
+        type_desc = get_type_description(info, subsubtype->name);
         if(type_desc){
-          subsubtype = xbt_dict_get_or_null(all_types, type_desc);
+          subsubtype = xbt_dict_get_or_null(info->types, type_desc);
         }else{
-          subsubtype = xbt_dict_get_or_null(other_types, get_type_description(other_types, subtype->name));
+          subsubtype = xbt_dict_get_or_null(other_info->types, get_type_description(other_info, subtype->name));
           switch_types = 1;
         }
       }
@@ -845,15 +845,15 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
     for(i=0; i<type->element_count; i++){
       // TODO, add support for variable stride (DW_AT_byte_stride)
       if(switch_types)
-        res = compare_heap_area_with_type((char *)real_area1 + (i*elm_size), (char *)real_area2 + (i*elm_size), (char *)area1 + (i*elm_size), (char *)area2 + (i*elm_size), previous, other_types, all_types, type->dw_type_id, subtype->byte_size, check_ignore, pointer_level);
+        res = compare_heap_area_with_type((char *)real_area1 + (i*elm_size), (char *)real_area2 + (i*elm_size), (char *)area1 + (i*elm_size), (char *)area2 + (i*elm_size), previous, other_info, info, type->dw_type_id, subtype->byte_size, check_ignore, pointer_level);
       else
-        res = compare_heap_area_with_type((char *)real_area1 + (i*elm_size), (char *)real_area2 + (i*elm_size), (char *)area1 + (i*elm_size), (char *)area2 + (i*elm_size), previous, all_types, other_types, type->dw_type_id, subtype->byte_size, check_ignore, pointer_level);
+        res = compare_heap_area_with_type((char *)real_area1 + (i*elm_size), (char *)real_area2 + (i*elm_size), (char *)area1 + (i*elm_size), (char *)area2 + (i*elm_size), previous, info, other_info, type->dw_type_id, subtype->byte_size, check_ignore, pointer_level);
       if(res == 1)
         return res;
     }
     break;
   case DW_TAG_pointer_type:
-    if(type->dw_type_id && ((dw_type_t)xbt_dict_get_or_null(all_types, type->dw_type_id))->type == DW_TAG_subroutine_type){
+    if(type->dw_type_id && ((dw_type_t)xbt_dict_get_or_null(info->types, type->dw_type_id))->type == DW_TAG_subroutine_type){
       addr_pointed1 = *((void **)(area1)); 
       addr_pointed2 = *((void **)(area2));
       return (addr_pointed1 != addr_pointed2);;
@@ -864,7 +864,7 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
           addr_pointed1 = *((void **)((char *)area1 + (i*sizeof(void *)))); 
           addr_pointed2 = *((void **)((char *)area2 + (i*sizeof(void *)))); 
           if(addr_pointed1 > s_heap && (char *)addr_pointed1 < (char*) s_heap + STD_HEAP_SIZE && addr_pointed2 > s_heap && (char *)addr_pointed2 < (char*) s_heap + STD_HEAP_SIZE)
-            res =  compare_heap_area(addr_pointed1, addr_pointed2, previous, all_types, other_types, type->dw_type_id, pointer_level); 
+            res =  compare_heap_area(addr_pointed1, addr_pointed2, previous, info, other_info, type->dw_type_id, pointer_level);
           else
             res =  (addr_pointed1 != addr_pointed2);
           if(res == 1)
@@ -874,7 +874,7 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
         addr_pointed1 = *((void **)(area1)); 
         addr_pointed2 = *((void **)(area2));
         if(addr_pointed1 > s_heap && (char *)addr_pointed1 < (char*) s_heap + STD_HEAP_SIZE && addr_pointed2 > s_heap && (char *)addr_pointed2 < (char*) s_heap + STD_HEAP_SIZE)
-          return compare_heap_area(addr_pointed1, addr_pointed2, previous, all_types, other_types, type->dw_type_id, pointer_level); 
+          return compare_heap_area(addr_pointed1, addr_pointed2, previous, info, other_info, type->dw_type_id, pointer_level);
         else
           return  (addr_pointed1 != addr_pointed2);
       }
@@ -882,11 +882,11 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
     break;
   case DW_TAG_structure_type:
     if(type->byte_size == 0){ /*declaration of the structure, need the complete description */
-      type_desc = get_type_description(all_types, type->name);
+      type_desc = get_type_description(info, type->name);
       if(type_desc){
-        type = xbt_dict_get_or_null(all_types, type_desc);
+        type = xbt_dict_get_or_null(info->types, type_desc);
       }else{
-        type = xbt_dict_get_or_null(other_types, get_type_description(other_types, type->name));
+        type = xbt_dict_get_or_null(other_info->types, get_type_description(other_info, type->name));
         switch_types = 1;
       }
     }
@@ -894,9 +894,9 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
       if(area_size>type->byte_size && area_size%type->byte_size == 0){
         for(i=0; i<(area_size/type->byte_size); i++){
           if(switch_types)
-            res = compare_heap_area_with_type((char *)real_area1 + (i*type->byte_size), (char *)real_area2 + (i*type->byte_size), (char *)area1 + (i*type->byte_size), (char *)area2 + (i*type->byte_size), previous, other_types, all_types, type_id, -1, check_ignore, 0);
+            res = compare_heap_area_with_type((char *)real_area1 + (i*type->byte_size), (char *)real_area2 + (i*type->byte_size), (char *)area1 + (i*type->byte_size), (char *)area2 + (i*type->byte_size), previous, other_info, info, type_id, -1, check_ignore, 0);
           else
-            res = compare_heap_area_with_type((char *)real_area1 + (i*type->byte_size), (char *)real_area2 + (i*type->byte_size), (char *)area1 + (i*type->byte_size), (char *)area2 + (i*type->byte_size), previous, all_types, other_types, type_id, -1, check_ignore, 0);
+            res = compare_heap_area_with_type((char *)real_area1 + (i*type->byte_size), (char *)real_area2 + (i*type->byte_size), (char *)area1 + (i*type->byte_size), (char *)area2 + (i*type->byte_size), previous, info, other_info, type_id, -1, check_ignore, 0);
           if(res == 1)
             return res;
         }
@@ -907,9 +907,9 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
       cursor = 0;
       xbt_dynar_foreach(type->members, cursor, member){ 
         if(switch_types)
-          res = compare_heap_area_with_type((char *)real_area1 + member->offset, (char *)real_area2 + member->offset, (char *)area1 + member->offset, (char *)area2 + member->offset, previous, other_types, all_types, member->dw_type_id, -1, check_ignore, 0);
+          res = compare_heap_area_with_type((char *)real_area1 + member->offset, (char *)real_area2 + member->offset, (char *)area1 + member->offset, (char *)area2 + member->offset, previous, other_info, info, member->dw_type_id, -1, check_ignore, 0);
         else
-          res = compare_heap_area_with_type((char *)real_area1 + member->offset, (char *)real_area2 + member->offset, (char *)area1 + member->offset, (char *)area2 + member->offset, previous, all_types, other_types, member->dw_type_id, -1, check_ignore, 0);  
+          res = compare_heap_area_with_type((char *)real_area1 + member->offset, (char *)real_area2 + member->offset, (char *)area1 + member->offset, (char *)area2 + member->offset, previous, info, other_info, member->dw_type_id, -1, check_ignore, 0);
         if(res == 1){
           return res;
         }
@@ -917,7 +917,7 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
     }
     break;
   case DW_TAG_union_type:
-    return compare_heap_area_without_type(real_area1, real_area2, area1, area2, previous, all_types, other_types, type->byte_size, check_ignore);
+    return compare_heap_area_without_type(real_area1, real_area2, area1, area2, previous, info, other_info, type->byte_size, check_ignore);
     break;
   default:
     break;
@@ -927,10 +927,10 @@ static int compare_heap_area_with_type(void *real_area1, void *real_area2, void
 
 }
 
-static char* get_offset_type(char* type_id, int offset, xbt_dict_t all_types, xbt_dict_t other_types, int area_size, int *switch_type){
-  dw_type_t type = xbt_dict_get_or_null(all_types, type_id);
+static char* get_offset_type(char* type_id, int offset, mc_object_info_t info, mc_object_info_t other_info, int area_size, int *switch_type){
+  dw_type_t type = xbt_dict_get_or_null(info->types, type_id);
   if(type == NULL){
-    type = xbt_dict_get_or_null(other_types, type_id);
+    type = xbt_dict_get_or_null(other_info->types, type_id);
     *switch_type = 1;
   }
   char* type_desc;
@@ -938,19 +938,19 @@ static char* get_offset_type(char* type_id, int offset, xbt_dict_t all_types, xb
   case DW_TAG_structure_type :
     if(type->byte_size == 0){ /*declaration of the structure, need the complete description */
       if(*switch_type == 0){
-        type_desc = get_type_description(all_types, type->name);
+        type_desc = get_type_description(info, type->name);
         if(type_desc){
-          type = xbt_dict_get_or_null(all_types, type_desc);
+          type = xbt_dict_get_or_null(info->types, type_desc);
         }else{
-          type = xbt_dict_get_or_null(other_types, get_type_description(other_types, type->name));
+          type = xbt_dict_get_or_null(other_info->types, get_type_description(other_info, type->name));
           *switch_type = 1;
         }
       }else{
-        type_desc = get_type_description(other_types, type->name);
+        type_desc = get_type_description(other_info, type->name);
         if(type_desc){
-          type = xbt_dict_get_or_null(other_types, type_desc);
+          type = xbt_dict_get_or_null(other_info->types, type_desc);
         }else{
-          type = xbt_dict_get_or_null(all_types, get_type_description(other_types, type->name));
+          type = xbt_dict_get_or_null(info->types, get_type_description(info, type->name));
           *switch_type = 0;
         }
       }
@@ -978,7 +978,7 @@ static char* get_offset_type(char* type_id, int offset, xbt_dict_t all_types, xb
   }
 }
 
-int compare_heap_area(void *area1, void* area2, xbt_dynar_t previous, xbt_dict_t all_types, xbt_dict_t other_types, char *type_id, int pointer_level){
+int compare_heap_area(void *area1, void* area2, xbt_dynar_t previous, mc_object_info_t info, mc_object_info_t other_info, char *type_id, int pointer_level){
 
   int res_compare;
   ssize_t block1, frag1, block2, frag2;
@@ -1028,16 +1028,16 @@ int compare_heap_area(void *area1, void* area2, xbt_dynar_t previous, xbt_dict_t
   real_addr_block2 = ((void*) (((ADDR2UINT(block2)) - 1) * BLOCKSIZE + (char*)((xbt_mheap_t)s_heap)->heapbase));
 
   if(type_id){
-    type = xbt_dict_get_or_null(all_types, type_id);
+    type = xbt_dict_get_or_null(info->types, type_id);
     if(type->byte_size == 0){
       if(type->dw_type_id == NULL){
-        type_desc = get_type_description(all_types, type->name);
+        type_desc = get_type_description(info, type->name);
         if(type_desc)
-          type = xbt_dict_get_or_null(all_types, type_desc);
+          type = xbt_dict_get_or_null(info->types, type_desc);
         else
-          type = xbt_dict_get_or_null(other_types, get_type_description(other_types, type->name));
+          type = xbt_dict_get_or_null(other_info->types, get_type_description(other_info, type->name));
       }else{
-        type = xbt_dict_get_or_null(all_types, type->dw_type_id);
+        type = xbt_dict_get_or_null(info->types, type->dw_type_id);
       }
     }
     if((type->byte_size == DW_TAG_pointer_type) || ((type->type == DW_TAG_base_type) && (!strcmp(type->name, "char"))))
@@ -1190,14 +1190,14 @@ int compare_heap_area(void *area1, void* area2, xbt_dynar_t previous, xbt_dict_t
       offset1 = (char *)area1 - (char *)real_addr_frag1;
       offset2 = (char *)area2 - (char *)real_addr_frag2;
       if(types1[block1][frag1] != NULL && types2[block2][frag2] != NULL){
-        new_type_id1 = get_offset_type(types1[block1][frag1], offset1, all_types, other_types, size, &switch_type);
-        new_type_id2 = get_offset_type(types2[block2][frag2], offset1, all_types, other_types, size, &switch_type);
+        new_type_id1 = get_offset_type(types1[block1][frag1], offset1, info, other_info, size, &switch_type);
+        new_type_id2 = get_offset_type(types2[block2][frag2], offset1, info, other_info, size, &switch_type);
       }else if(types1[block1][frag1] != NULL){
-        new_type_id1 = get_offset_type(types1[block1][frag1], offset1, all_types, other_types, size, &switch_type);
-        new_type_id2 = get_offset_type(types1[block1][frag1], offset2, all_types, other_types, size, &switch_type);       
+        new_type_id1 = get_offset_type(types1[block1][frag1], offset1, info, other_info, size, &switch_type);
+        new_type_id2 = get_offset_type(types1[block1][frag1], offset2, info, other_info, size, &switch_type);
       }else if(types2[block2][frag2] != NULL){
-        new_type_id1 = get_offset_type(types2[block2][frag2], offset1, all_types, other_types, size, &switch_type);
-        new_type_id2 = get_offset_type(types2[block2][frag2], offset2, all_types, other_types, size, &switch_type);
+        new_type_id1 = get_offset_type(types2[block2][frag2], offset1, info, other_info, size, &switch_type);
+        new_type_id2 = get_offset_type(types2[block2][frag2], offset2, info, other_info, size, &switch_type);
       }else{
         if(match_pairs){
           match_equals(previous);
@@ -1208,22 +1208,22 @@ int compare_heap_area(void *area1, void* area2, xbt_dynar_t previous, xbt_dict_t
 
       if(new_type_id1 !=  NULL && new_type_id2 !=  NULL && !strcmp(new_type_id1, new_type_id2)){
         if(switch_type){
-          type = xbt_dict_get_or_null(other_types, new_type_id1);
+          type = xbt_dict_get_or_null(other_info->types, new_type_id1);
           while(type->byte_size == 0 && type->dw_type_id != NULL)
-            type = xbt_dict_get_or_null(other_types, type->dw_type_id);
+            type = xbt_dict_get_or_null(other_info->types, type->dw_type_id);
           new_size1 = type->byte_size;
-          type = xbt_dict_get_or_null(other_types, new_type_id2);
+          type = xbt_dict_get_or_null(other_info->types, new_type_id2);
           while(type->byte_size == 0 && type->dw_type_id != NULL)
-            type = xbt_dict_get_or_null(other_types, type->dw_type_id);
+            type = xbt_dict_get_or_null(other_info->types, type->dw_type_id);
           new_size2 = type->byte_size;
         }else{
-          type = xbt_dict_get_or_null(all_types, new_type_id1);
+          type = xbt_dict_get_or_null(info->types, new_type_id1);
           while(type->byte_size == 0 && type->dw_type_id != NULL)
-            type = xbt_dict_get_or_null(all_types, type->dw_type_id);
+            type = xbt_dict_get_or_null(info->types, type->dw_type_id);
           new_size1 = type->byte_size;
-          type = xbt_dict_get_or_null(all_types, new_type_id2);
+          type = xbt_dict_get_or_null(info->types, new_type_id2);
           while(type->byte_size == 0 && type->dw_type_id != NULL)
-            type = xbt_dict_get_or_null(all_types, type->dw_type_id);
+            type = xbt_dict_get_or_null(info->types, type->dw_type_id);
           new_size2 = type->byte_size;
         }
       }else{
@@ -1277,9 +1277,9 @@ int compare_heap_area(void *area1, void* area2, xbt_dynar_t previous, xbt_dict_t
   /* Start comparison*/
   if(type_id != NULL){
     if(switch_type)
-      res_compare = compare_heap_area_with_type(area1, area2, area1_to_compare, area2_to_compare, previous, other_types, all_types, type_id, size, check_ignore, pointer_level);
+      res_compare = compare_heap_area_with_type(area1, area2, area1_to_compare, area2_to_compare, previous, other_info, info, type_id, size, check_ignore, pointer_level);
     else
-      res_compare = compare_heap_area_with_type(area1, area2, area1_to_compare, area2_to_compare, previous, all_types, other_types, type_id, size, check_ignore, pointer_level);
+      res_compare = compare_heap_area_with_type(area1, area2, area1_to_compare, area2_to_compare, previous, info, other_info, type_id, size, check_ignore, pointer_level);
     if(res_compare == 1){
       if(match_pairs)
         xbt_dynar_free(&previous);
@@ -1287,9 +1287,9 @@ int compare_heap_area(void *area1, void* area2, xbt_dynar_t previous, xbt_dict_t
     }
   }else{
     if(switch_type)
-      res_compare = compare_heap_area_without_type(area1, area2, area1_to_compare, area2_to_compare, previous, other_types, all_types, size, check_ignore);
+      res_compare = compare_heap_area_without_type(area1, area2, area1_to_compare, area2_to_compare, previous, other_info, info, size, check_ignore);
     else
-      res_compare = compare_heap_area_without_type(area1, area2, area1_to_compare, area2_to_compare, previous, all_types, other_types, size, check_ignore);
+      res_compare = compare_heap_area_without_type(area1, area2, area1_to_compare, area2_to_compare, previous, info, other_info, size, check_ignore);
     if(res_compare == 1){
       if(match_pairs)
         xbt_dynar_free(&previous);
@@ -1335,13 +1335,13 @@ int get_pointed_area_size(void *area, int heap){
 
 }
 
-char *get_type_description(xbt_dict_t types, char *type_name){
+char *get_type_description(mc_object_info_t info, char *type_name){
 
   xbt_dict_cursor_t dict_cursor;
   char *type_origin;
   dw_type_t type;
 
-  xbt_dict_foreach(types, dict_cursor, type_origin, type){
+  xbt_dict_foreach(info->types, dict_cursor, type_origin, type){
     if(type->name && (strcmp(type->name, type_name) == 0) && type->byte_size > 0){
       xbt_dict_cursor_free(&dict_cursor);
       return type_origin;