--- /dev/null
+/* Copyright (c) 2016. 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. */
+
+#ifndef SIMGRID_XBT_RANGE_HPP
+#define SIMGRID_XBT_RANGE_HPP
+
+namespace simgrid {
+namespace xbt {
+
+/** Describes a contiguous inclusive-exclusive [a,b) range of values */
+template<class T> class range {
+ T begin_;
+ T end_;
+public:
+ range() : begin_(), end_() {}
+ range(T begin, T end) : begin_(std::move(begin)), end_(std::move(end)) {}
+ range(T value) : begin_(value), end_(value + 1) {}
+ T& begin() { return begin_; }
+ T& end() { return end_; }
+ const T& begin() const { return begin_; }
+ const T& end() const { return end_; }
+ bool empty() const { return begin_ >= end_; }
+ bool contain(T const& x) const { return begin_ <= x && end_ > x; }
+};
+
+}
+}
+
+#endif
#include <string>
#include <xbt/base.h>
+#include <xbt/range.hpp>
#include "src/mc/mc_forward.h"
#include "src/mc/LocationList.hpp"
namespace simgrid {
namespace mc {
+/** Debug information about a given function or scope within a function */
class Frame {
public:
Frame();
int tag;
std::string name;
- void *low_pc;
- void *high_pc;
+ /** Range of instruction addresses for which this scope is valid */
+ simgrid::xbt::range<std::uint64_t> range;
simgrid::dwarf::LocationList frame_base_location;
std::vector<Variable> variables;
unsigned long int id; /* DWARF offset of the subprogram */
Frame::Frame()
{
this->tag = 0;
- this->low_pc = nullptr;
- this->high_pc = nullptr;
+ this->range = {0, 0};
this->id = 0;
this->abstract_origin_id = 0;
this->object_info = nullptr;
* Either we have found the correct function or we do not know
* any function corresponding to this instruction address.
* Only at the point do we derefernce the function pointer. */
- else if (ip < base[k].function->high_pc)
+ else if ((std::uint64_t) ip < base[k].function->range.end())
return base[k].function;
else
return nullptr;
const void *ip)
{
// The variable is not yet valid:
- if ((const void *) ((const char *) scope->low_pc + var->start_scope) > ip)
+ if (scope->range.begin() + var->start_scope > (std::uint64_t) ip)
return false;
else
return true;
{
simgrid::mc::Process* process = &mc_model_checker->process();
- void *ip = (void *) stack_frame->ip;
- if (ip < scope->low_pc || ip >= scope->high_pc)
+ if (!scope->range.contain(stack_frame->ip))
return;
for(simgrid::mc::Variable& current_variable :
// This is the base address for DWARF addresses.
// Relocated addresses are offset from this base address.
// See DWARF4 spec 7.5
- void *base = info->base_address();
+ std::uint64_t base = (std::uint64_t) info->base_address();
// TODO, support DW_AT_ranges
uint64_t low_pc = MC_dwarf_attr_integrate_addr(die, DW_AT_low_pc);
- frame.low_pc = low_pc ? ((char *) base) + low_pc : 0;
+ frame.range.begin() = low_pc ? (std::uint64_t) base + low_pc : 0;
if (low_pc) {
// DW_AT_high_pc:
Dwarf_Attribute attr;
if (dwarf_formsdata(&attr, &offset) != 0)
xbt_die("Could not read constant");
- frame.high_pc = (void *) ((char *) frame.low_pc + offset);
+ frame.range.end() = frame.range.begin() + offset;
break;
// DW_AT_high_pc is a relocatable address:
case simgrid::dwarf::FormClass::Address:
if (dwarf_formaddr(&attr, &high_pc) != 0)
xbt_die("Could not read address");
- frame.high_pc = ((char *) base) + high_pc;
+ frame.range.begin() = base + high_pc;
break;
default:
info->functions_index.clear();
for (auto& e : info->subprograms) {
- if (e.second.low_pc == nullptr)
+ if (e.second.range.begin() == 0)
continue;
simgrid::mc::FunctionIndexEntry entry;
- entry.low_pc = e.second.low_pc;
+ entry.low_pc = (void*) e.second.range.begin();
entry.function = &e.second;
info->functions_index.push_back(entry);
}
simgrid::mc::Frame* frame = context->process->find_function(remote(addr));
if (!frame)
return - UNW_ENOINFO;
- *offp = (unw_word_t) frame->low_pc - addr;
+ *offp = (unw_word_t) frame->range.begin() - addr;
strncpy(bufp, frame->name.c_str(), buf_len);
if (bufp[buf_len - 1]) {
include/xbt/mmalloc.h
include/xbt/module.h
include/xbt/parmap.h
+ include/xbt/range.hpp
include/xbt/replay.h
include/xbt/str.h
include/xbt/strbuff.h