-/* mc_diff - Memory snapshooting and comparison */
-
/* Copyright (c) 2008-2015. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
+/* mc_diff - Memory snapshooting and comparison */
+
#include "src/xbt/ex_interface.h" /* internals of backtrace setup */
#include "xbt/str.h"
#include "mc/mc.h"
#include "xbt/mmalloc.h"
-#include "src/mc/mc_object_info.h"
#include "mc/datatypes.h"
#include "src/mc/mc_private.h"
#include "src/mc/mc_snapshot.h"
static void heap_area_pair_free(heap_area_pair_t pair)
{
xbt_free(pair);
- pair = NULL;
+ pair = nullptr;
}
static void heap_area_pair_free_voidp(void *d)
static void heap_area_free(heap_area_t area)
{
xbt_free(area);
- area = NULL;
+ area = nullptr;
}
/************************************************************************************/
{
if (is_new_heap_area_pair(list, block1, fragment1, block2, fragment2)) {
- heap_area_pair_t pair = NULL;
+ heap_area_pair_t pair = nullptr;
pair = xbt_new0(s_heap_area_pair_t, 1);
pair->block1 = block1;
pair->fragment1 = fragment1;
std::vector<simgrid::mc::IgnoredHeapRegion>* i1,
std::vector<simgrid::mc::IgnoredHeapRegion>* i2)
{
- if (mc_diff_info == NULL) {
+ if (mc_diff_info == nullptr) {
mc_diff_info = xbt_new0(struct s_mc_diff, 1);
- mc_diff_info->equals_to1 = NULL;
- mc_diff_info->equals_to2 = NULL;
- mc_diff_info->types1 = NULL;
- mc_diff_info->types2 = NULL;
+ mc_diff_info->equals_to1 = nullptr;
+ mc_diff_info->equals_to2 = nullptr;
+ mc_diff_info->types1 = nullptr;
+ mc_diff_info->types2 = nullptr;
}
struct s_mc_diff *state = mc_diff_info;
const malloc_info* heapinfos2 = snapshot2->read<malloc_info*>(
(std::uint64_t)heapinfo_address, simgrid::mc::ProcessIndexMissing);
- while (i1 < state->heaplimit) {
+ while (i1 <= state->heaplimit) {
const malloc_info* heapinfo1 = (const malloc_info*) MC_region_read(heap_region1, &heapinfo_temp1, &heapinfos1[i1], sizeof(malloc_info));
const malloc_info* heapinfo2 = (const malloc_info*) MC_region_read(heap_region2, &heapinfo_temp2, &heapinfos2[i1], sizeof(malloc_info));
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2, snapshot1, snapshot2,
- NULL, NULL, 0);
+ nullptr, NULL, 0);
if (res_compare != 1) {
for (k = 1; k < heapinfo2->busy_block.size; k++)
}
- while (i2 < state->heaplimit && !equal) {
+ while (i2 <= state->heaplimit && !equal) {
addr_block2 = (ADDR2UINT(i2) - 1) * BLOCKSIZE +
(char *) state->std_heap_copy.heapbase;
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2, snapshot1, snapshot2,
- NULL, NULL, 0);
+ nullptr, NULL, 0);
if (res_compare != 1) {
for (k = 1; k < heapinfo2b->busy_block.size; k++)
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot1, snapshot2,
- NULL, NULL, 0);
+ nullptr, NULL, 0);
if (res_compare != 1)
equal = 1;
}
- while (i2 < state->heaplimit && !equal) {
+ while (i2 <= state->heaplimit && !equal) {
const malloc_info* heapinfo2b = (const malloc_info*) MC_region_read(
heap_region2, &heapinfo_temp2b, &heapinfos2[i2],
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot2, snapshot2,
- NULL, NULL, 0);
+ nullptr, NULL, 0);
if (res_compare != 1) {
equal = 1;
/* All blocks/fragments are equal to another block/fragment ? */
size_t i = 1, j = 0;
- for(i = 1; i < state->heaplimit; i++) {
+ for(i = 1; i <= state->heaplimit; i++) {
const malloc_info* heapinfo1 = (const malloc_info*) MC_region_read(
heap_region1, &heapinfo_temp1, &heapinfos1[i], sizeof(malloc_info));
if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED) {
if (i1 == state->heaplimit)
XBT_DEBUG("Number of blocks/fragments not found in heap1 : %d", nb_diff1);
- for (i=1; i < state->heaplimit; i++) {
+ for (i=1; i <= state->heaplimit; i++) {
const malloc_info* heapinfo2 = (const malloc_info*) MC_region_read(
heap_region2, &heapinfo_temp2, &heapinfos2[i], sizeof(malloc_info));
if (heapinfo2->type == MMALLOC_TYPE_UNFRAGMENTED) {
// Both addreses are in the heap:
res_compare =
compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1,
- snapshot2, previous, NULL, 0);
+ snapshot2, previous, nullptr, 0);
if (res_compare == 1) {
return res_compare;
}
int pointer_level)
{
top:
- if (is_stack(real_area1) && is_stack(real_area2))
+ // HACK: This should not happen but in pratice, there is some
+ // DW_TAG_typedef without DW_AT_type. We should fix this somehow.
+ if (type == nullptr)
return 0;
+ if (is_stack(real_area1) && is_stack(real_area2))
+ return 0;
ssize_t ignore1, ignore2;
if ((check_ignore > 0)
void *real_member2 = simgrid::dwarf::resolve_member(
real_area2, type, &member, (simgrid::mc::AddressSpace*) snapshot2, process_index);
res =
- compare_heap_area_with_type(state, process_index, real_member1, real_member2,
+ compare_heap_area_with_type(state, process_index, real_member1, real_member2,
snapshot1, snapshot2,
previous, member.type, -1,
check_ignore, 0);
if (area_size > type->byte_size && area_size % type->byte_size == 0)
return type;
else
- return NULL;
+ return nullptr;
} else {
for(simgrid::mc::Member& member : type->members) {
}
}
- return NULL;
+ return nullptr;
}
break;
default:
/* FIXME : other cases ? */
- return NULL;
+ return nullptr;
break;
}
}
* @param area2 Process address for state 2
* @param snapshot1 Snapshot of state 1
* @param snapshot2 Snapshot of state 2
- * @param previous Pairs of blocks already compared on the current path (or NULL)
+ * @param previous Pairs of blocks already compared on the current path (or nullptr)
* @param type_id Type of variable
* @param pointer_level
* @return 0 (same), 1 (different), -1
int type_size = -1;
int offset1 = 0, offset2 = 0;
int new_size1 = -1, new_size2 = -1;
- simgrid::mc::Type *new_type1 = NULL, *new_type2 = NULL;
+ simgrid::mc::Type *new_type1 = nullptr, *new_type2 = NULL;
int match_pairs = 0;
malloc_info heapinfo_temp1, heapinfo_temp2;
- if (previous == NULL) {
+ if (previous == nullptr) {
previous =
xbt_dynar_new(sizeof(heap_area_pair_t), heap_area_pair_free_voidp);
match_pairs = 1;
type = type->full_type;
// This assume that for "boring" types (volatile ...) byte_size is absent:
- while (type->byte_size == 0 && type->subtype != NULL)
+ while (type->byte_size == 0 && type->subtype != nullptr)
type = type->subtype;
// Find type_size:
// Remember (basic) type inference.
// The current data structure only allows us to do this for the whole block.
- if (type != NULL && area1 == real_addr_block1) {
+ if (type != nullptr && area1 == real_addr_block1) {
state->types1_(block1, 0) = type;
}
- if (type != NULL && area2 == real_addr_block2) {
+ if (type != nullptr && area2 == real_addr_block2) {
state->types2_(block2, 0) = type;
}
// Remember (basic) type inference.
// The current data structure only allows us to do this for the whole fragment.
- if (type != NULL && area1 == real_addr_frag1) {
+ if (type != nullptr && area1 == real_addr_frag1) {
state->types1_(block1, frag1) = type;
}
- if (type != NULL && area2 == real_addr_frag2) {
+ if (type != nullptr && area2 == real_addr_frag2) {
state->types2_(block2, frag2) = type;
}
// The type of the variable is already known:
new_type2 = type;
}
// Type inference from the block type.
- else if (state->types1_(block1, frag1) != NULL
- || state->types2_(block2, frag2) != NULL) {
+ else if (state->types1_(block1, frag1) != nullptr
+ || state->types2_(block2, frag2) != nullptr) {
offset1 = (char *) area1 - (char *) real_addr_frag1;
offset2 = (char *) area2 - (char *) real_addr_frag2;
- if (state->types1_(block1, frag1) != NULL
- && state->types2_(block2, frag2) != NULL) {
+ if (state->types1_(block1, frag1) != nullptr
+ && state->types2_(block2, frag2) != nullptr) {
new_type1 =
get_offset_type(real_addr_frag1, state->types1_(block1, frag1),
offset1, size, snapshot1, process_index);
new_type2 =
get_offset_type(real_addr_frag2, state->types2_(block2, frag2),
offset1, size, snapshot2, process_index);
- } else if (state->types1_(block1, frag1) != NULL) {
+ } else if (state->types1_(block1, frag1) != nullptr) {
new_type1 =
get_offset_type(real_addr_frag1, state->types1_(block1, frag1),
offset1, size, snapshot1, process_index);
new_type2 =
get_offset_type(real_addr_frag2, state->types1_(block1, frag1),
offset2, size, snapshot2, process_index);
- } else if (state->types2_(block2, frag2) != NULL) {
+ } else if (state->types2_(block2, frag2) != nullptr) {
new_type1 =
get_offset_type(real_addr_frag1, state->types2_(block2, frag2),
offset1, size, snapshot1, process_index);
return -1;
}
- if (new_type1 != NULL && new_type2 != NULL && new_type1 != new_type2) {
+ if (new_type1 != nullptr && new_type2 != NULL && new_type1 != new_type2) {
type = new_type1;
- while (type->byte_size == 0 && type->subtype != NULL)
+ while (type->byte_size == 0 && type->subtype != nullptr)
type = type->subtype;
new_size1 = type->byte_size;
type = new_type2;
- while (type->byte_size == 0 && type->subtype != NULL)
+ while (type->byte_size == 0 && type->subtype != nullptr)
type = type->subtype;
new_size2 = type->byte_size;
struct s_mc_diff *state = mc_diff_info;
- if (heap1 == NULL && heap1 == NULL) {
+ if (heap1 == nullptr && heap1 == NULL) {
XBT_DEBUG("Malloc descriptors null");
return 0;
}
