/* 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. */
-/** \file compare.cpp Memory snapshooting and comparison */
+/** \file compare.cpp Memory snapshotting and comparison */
#include "src/mc/mc_config.hpp"
#include "src/mc/mc_private.hpp"
int fragment_ = 0;
HeapLocation() = default;
- HeapLocation(int block, int fragment = 0) : block_(block), fragment_(fragment) {}
+ explicit HeapLocation(int block, int fragment = 0) : block_(block), fragment_(fragment) {}
bool operator==(HeapLocation const& that) const
{
return -1;
}
-static bool is_on_heap(const void* address)
-{
- const xbt_mheap_t heap = mc_model_checker->process().get_heap();
- return address >= heap->heapbase && address < heap->breakval;
-}
-
static bool is_stack(const void *address)
{
for (auto const& stack : mc_model_checker->process().stack_areas())
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 =
continue;
}
- if (heapinfo1->type < 0) {
- fprintf(stderr, "Unkown mmalloc block type.\n");
- abort();
- }
+ xbt_assert(heapinfo1->type >= 0, "Unkown mmalloc block type: %d", heapinfo1->type);
void* addr_block1 = ((void*)(((ADDR2UINT(i1)) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase));
- if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED) { /* Large block */
-
+ if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED) { /* Large block */
if (is_stack(addr_block1)) {
for (size_t k = 0; k < heapinfo1->busy_block.size; k++)
state.equals_to_<1>(i1 + k, 0) = HeapArea(i1, -1);
}
while (i2 < state.heaplimit && not equal) {
-
void* addr_block2 = (ADDR2UINT(i2) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase;
if (i2 == i1) {
}
while (i2 < state.heaplimit && not equal) {
-
const malloc_info* heapinfo2b =
(const malloc_info*)heap_region2->read(&heapinfo_temp2b, &heapinfos2[i2], sizeof(malloc_info));
continue;
}
- if (heapinfo2b->type < 0) {
- fprintf(stderr, "Unknown mmalloc block type.\n");
- abort();
- }
+ xbt_assert(heapinfo2b->type >= 0, "Unkown mmalloc block type: %d", heapinfo2b->type);
for (size_t j2 = 0; j2 < (size_t)(BLOCKSIZE >> heapinfo2b->type); j2++) {
-
if (i2 == i1 && j2 == j1)
continue;
simgrid::mc::Region* heap_region2 = MC_get_heap_region(snapshot2);
for (int i = 0; i < size; ) {
-
if (check_ignore > 0) {
ssize_t ignore1 = heap_comparison_ignore_size(state.processStates[0].to_ignore, (const char*)real_area1 + i);
if (ignore1 != -1) {
ssize_t ignore2 = heap_comparison_ignore_size(state.processStates[1].to_ignore, (const char*)real_area2 + i);
if (ignore2 == ignore1) {
if (ignore1 == 0) {
- check_ignore--;
return false;
} else {
i = i + ignore2;
if (MC_snapshot_region_memcmp((const char*)real_area1 + i, heap_region1, (const char*)real_area2 + i, heap_region2,
1) != 0) {
-
int pointer_align = (i / sizeof(void *)) * sizeof(void *);
- const void* addr_pointed1 = snapshot1.read(remote((void**)((const char*)real_area1 + pointer_align)));
- const void* addr_pointed2 = snapshot2.read(remote((void**)((const char*)real_area2 + pointer_align)));
+ const void* addr_pointed1 = snapshot1.read(remote((void* const*)((const char*)real_area1 + pointer_align)));
+ const void* addr_pointed2 = snapshot2.read(remote((void* const*)((const char*)real_area2 + pointer_align)));
if (process.in_maestro_stack(remote(addr_pointed1)) && process.in_maestro_stack(remote(addr_pointed2))) {
i = pointer_align + sizeof(void *);
continue;
}
- if (is_on_heap(addr_pointed1) && is_on_heap(addr_pointed2)) {
+ if (snapshot1.on_heap(addr_pointed1) && snapshot2.on_heap(addr_pointed2)) {
// Both addresses are in the heap:
if (heap_area_differ(state, addr_pointed1, addr_pointed2, snapshot1, snapshot2, previous, nullptr, 0))
return true;
const simgrid::mc::Snapshot& snapshot2, HeapLocationPairs* previous,
simgrid::mc::Type* type, int area_size, int check_ignore, int pointer_level)
{
- // HACK: This should not happen but in pratice, there are some
+ // HACK: This should not happen but in practice, there are some
// DW_TAG_typedef without an associated DW_AT_type:
//<1><538832>: Abbrev Number: 111 (DW_TAG_typedef)
// <538833> DW_AT_name : (indirect string, offset: 0x2292f3): gregset_t
if (pointer_level <= 1) {
addr_pointed1 = snapshot1.read(remote((void* const*)real_area1));
addr_pointed2 = snapshot2.read(remote((void* const*)real_area2));
- if (is_on_heap(addr_pointed1) && is_on_heap(addr_pointed2))
+ if (snapshot1.on_heap(addr_pointed1) && snapshot2.on_heap(addr_pointed2))
return heap_area_differ(state, addr_pointed1, addr_pointed2, snapshot1, snapshot2, previous, type->subtype,
pointer_level);
else
for (size_t i = 0; i < (area_size / sizeof(void*)); i++) {
addr_pointed1 = snapshot1.read(remote((void* const*)((const char*)real_area1 + i * sizeof(void*))));
addr_pointed2 = snapshot2.read(remote((void* const*)((const char*)real_area2 + i * sizeof(void*))));
- bool differ = is_on_heap(addr_pointed1) && is_on_heap(addr_pointed2)
+ bool differ = snapshot1.on_heap(addr_pointed1) && snapshot2.on_heap(addr_pointed2)
? heap_area_differ(state, addr_pointed1, addr_pointed2, snapshot1, snapshot2, previous,
type->subtype, pointer_level)
: addr_pointed1 != addr_pointed2;
case DW_TAG_class_type:
if (type->full_type)
type = type->full_type;
+ if (type->byte_size == 0)
+ return false;
if (area_size != -1 && type->byte_size != area_size) {
if (area_size <= type->byte_size || area_size % type->byte_size != 0)
return false;
type->byte_size, check_ignore);
default:
- XBT_VERB("Unknown case: %d", type->type);
- break;
+ THROW_IMPOSSIBLE;
}
- return false;
}
/** Infer the type of a part of the block from the type of the block
static simgrid::mc::Type* get_offset_type(void* real_base_address, simgrid::mc::Type* type, int offset, int area_size,
const simgrid::mc::Snapshot& snapshot)
{
-
- // Beginning of the block, the infered variable type if the type of the block:
+ // Beginning of the block, the inferred variable type if the type of the block:
if (offset == 0)
return type;
switch (type->type) {
-
case DW_TAG_structure_type:
case DW_TAG_class_type:
if (type->full_type)
default:
/* FIXME: other cases ? */
return nullptr;
-
}
}
type_size = -1;
else
type_size = type->byte_size;
-
}
simgrid::mc::Region* heap_region1 = MC_get_heap_region(snapshot1);
check_ignore = heapinfo1->busy_block.ignore;
} 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;
}
// Type inference from the block type.
else if (state.types_<1>(block1, frag1) != nullptr || state.types_<2>(block2, frag2) != nullptr) {
-
offset1 = (char*)area1 - (char*)real_addr_frag1;
offset2 = (char*)area2 - (char*)real_addr_frag2;
}
for (i = 0; i < type->element_count; i++) {
size_t off = i * elm_size;
- if (areas_differ_with_type(state, (char*)real_area1 + off, snapshot1, region1, (char*)real_area2 + off,
- snapshot2, region2, type->subtype, pointer_level))
+ if (areas_differ_with_type(state, (const char*)real_area1 + off, snapshot1, region1,
+ (const char*)real_area2 + off, snapshot2, region2, type->subtype, pointer_level))
return true;
}
break;
// * a pointer leads to the read-only segment of the current object
// * a pointer lead to a different ELF object
- if (is_on_heap(addr_pointed1)) {
- if (not is_on_heap(addr_pointed2))
+ if (snapshot1.on_heap(addr_pointed1)) {
+ if (not snapshot2.on_heap(addr_pointed2))
return true;
// The pointers are both in the heap:
return simgrid::mc::heap_area_differ(state, addr_pointed1, addr_pointed2, snapshot1, snapshot2, nullptr,
return areas_differ_with_type(state, addr_pointed1, snapshot1, region1, addr_pointed2, snapshot2, region2,
type->subtype, pointer_level);
} else {
-
// TODO, We do not handle very well the case where
// it belongs to a different (non-heap) region from the current one.
{
xbt_assert(r1 && r2, "Missing region.");
- std::vector<simgrid::mc::Variable>& variables = object_info->global_variables;
+ const std::vector<simgrid::mc::Variable>& variables = object_info->global_variables;
for (simgrid::mc::Variable const& current_var : variables) {
-
// 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.
continue;
simgrid::mc::Type* bvariable_type = current_var.type;
- if (areas_differ_with_type(state, (char*)current_var.address, snapshot1, r1, (char*)current_var.address, snapshot2,
- r2, bvariable_type, 0)) {
- XBT_VERB("Global variable %s (%p) is different between snapshots",
- current_var.name.c_str(),
- (char *) current_var.address);
+ if (areas_differ_with_type(state, current_var.address, snapshot1, r1, current_var.address, snapshot2, r2,
+ bvariable_type, 0)) {
+ XBT_VERB("Global variable %s (%p) is different between snapshots", current_var.name.c_str(), current_var.address);
return true;
}
}
if (current_var1->name != current_var2->name || current_var1->subprogram != current_var2->subprogram ||
current_var1->ip != current_var2->ip) {
// TODO, fix current_varX->subprogram->name to include name if DW_TAG_inlined_subprogram
- XBT_VERB("Different name of variable (%s - %s) "
- "or frame (%s - %s) or ip (%lu - %lu)",
- current_var1->name.c_str(), current_var2->name.c_str(), current_var1->subprogram->name.c_str(),
+ XBT_VERB("Different name of variable (%s - %s) or frame (%s - %s) or ip (%lu - %lu)", current_var1->name.c_str(),
+ current_var2->name.c_str(), current_var1->subprogram->name.c_str(),
current_var2->subprogram->name.c_str(), current_var1->ip, current_var2->ip);
return true;
}
if (areas_differ_with_type(state, current_var1->address, snapshot1, snapshot1.get_region(current_var1->address),
current_var2->address, snapshot2, snapshot2.get_region(current_var2->address),
current_var1->type, 0)) {
- XBT_VERB("Local variable %s (%p - %p) in frame %s "
- "is different between snapshots",
- current_var1->name.c_str(), current_var1->address, current_var2->address,
- current_var1->subprogram->name.c_str());
+ XBT_VERB("Local variable %s (%p - %p) in frame %s is different between snapshots", current_var1->name.c_str(),
+ current_var1->address, current_var2->address, current_var1->subprogram->name.c_str());
return true;
}
}
