#include <memory>
#include <utility>
+#include <fcntl.h>
#include <cstdlib>
#define DW_LANG_Objc DW_LANG_ObjC /* fix spelling error in older dwarf.h */
#include <dwarf.h>
#include <elfutils/libdw.h>
+#include <boost/algorithm/string/predicate.hpp>
+
#include <simgrid_config.h>
#include "src/simgrid/util.hpp"
#include <xbt/log.h>
#include "src/mc/mc_private.h"
#include "src/mc/mc_dwarf.hpp"
-#include "src/mc/mc_object_info.h"
#include "src/mc/Process.hpp"
#include "src/mc/ObjectInformation.hpp"
#include "src/mc/Variable.hpp"
// TODO, we should use another type (because is is not a type but a member)
simgrid::mc::Member member;
- member.inheritance = tag == DW_TAG_inheritance;
+ if (tag == DW_TAG_inheritance)
+ member.flags |= simgrid::mc::Member::INHERITANCE_FLAG;
const char *name = MC_dwarf_attr_integrate_string(&child, DW_AT_name);
if (name)
member.name = name;
+ // Those base names are used by GCC and clang for virtual table pointers
+ // respectively ("__vptr$ClassName", "__vptr.ClassName"):
+ if (boost::algorithm::starts_with(member.name, "__vptr$") ||
+ boost::algorithm::starts_with(member.name, "__vptr."))
+ member.flags |= simgrid::mc::Member::VIRTUAL_POINTER_FLAG;
+ // A cleaner stolution would be to check against the type:
+ // ---
+ // tag: DW_TAG_member
+ // name: "_vptr$Foo"
+ // type:
+ // # Type for a pointer to a vtable
+ // tag: DW_TAG_pointer_type
+ // type:
+ // # Type for a vtable:
+ // tag: DW_TAG_pointer_type
+ // name: "__vtbl_ptr_type"
+ // type:
+ // tag: DW_TAG_subroutine_type
+ // type:
+ // tag: DW_TAG_base_type
+ // name: "int"
+ // ---
+
member.byte_size =
MC_dwarf_attr_integrate_uint(&child, DW_AT_byte_size, 0);
member.type_id = MC_dwarf_at_type(&child);
break;
}
- return std::move(type);
+ return type;
}
static void MC_dwarf_handle_type_die(simgrid::mc::ObjectInformation* info, Dwarf_Die * die,
std::unique_ptr<simgrid::mc::Variable> variable =
std::unique_ptr<simgrid::mc::Variable>(new simgrid::mc::Variable());
- variable->dwarf_offset = dwarf_dieoffset(die);
+ variable->id = dwarf_dieoffset(die);
variable->global = frame == nullptr; // Can be override base on DW_AT_location
variable->object_info = info;
xbt_die(
"Could not read location expression in DW_AT_location "
"of variable <%" PRIx64 ">%s",
- (uint64_t) variable->dwarf_offset,
+ (uint64_t) variable->id,
variable->name.c_str());
}
if (len == 1 && expr[0].atom == DW_OP_addr) {
- variable->global = 1;
+ variable->global = true;
uintptr_t offset = (uintptr_t) expr[0].number;
uintptr_t base = (uintptr_t) info->base_address();
variable->address = (void *) (base + offset);
xbt_die("Unexpected form 0x%x (%i), class 0x%x (%i) list for location "
"in <%" PRIx64 ">%s",
form, form, (int) form_class, (int) form_class,
- (uint64_t) variable->dwarf_offset,
+ (uint64_t) variable->id,
variable->name.c_str());
}
variable->name =
"@anonymous#" + std::to_string(mc_anonymous_variable_index++);
- return std::move(variable);
+ return variable;
}
static void MC_dwarf_handle_variable_die(simgrid::mc::ObjectInformation* info, Dwarf_Die * die,
case simgrid::dwarf::FormClass::Address:
if (dwarf_formaddr(&attr, &high_pc) != 0)
xbt_die("Could not read address");
- frame.range.begin() = base + high_pc;
+ frame.range.end() = base + high_pc;
break;
default:
Dwarf_Off next_offset = 0;
size_t length;
- while (dwarf_nextcu(dwarf, offset, &next_offset, &length, nullptr, NULL, NULL) ==
+ while (dwarf_nextcu(dwarf, offset, &next_offset, &length, nullptr, nullptr, nullptr) ==
0) {
Dwarf_Die unit_die;
if (dwarf_offdie(dwarf, offset + length, &unit_die) != nullptr)
- MC_dwarf_handle_children(info, &unit_die, &unit_die, nullptr, NULL);
+ MC_dwarf_handle_children(info, &unit_die, &unit_die, nullptr, nullptr);
offset = next_offset;
}
}
static inline
std::array<char, 2> to_hex(std::uint8_t byte)
{
- return { hexdigits[byte >> 4], hexdigits[byte & 0xF] };
+ // Horrid double braces!
+ // Apparently, this is needed in C++11 (not in C++14).
+ return { { hexdigits[byte >> 4], hexdigits[byte & 0xF] } };
}
/** Binary data to hexadecimal */
for (int j = 0; j < 2; ++j)
res[2 * i + j] = hex_byte[j];
}
- return std::move(res);
+ return res;
}
/** Binary data to hexadecimal */
}
/** Base directories for external debug files */
+static
const char* debug_paths[] = {
"/usr/lib/debug/",
"/usr/local/lib/debug/",
+ to_hex(id.data() + 1, id.size() - 1) + ".debug";
XBT_DEBUG("Checking debug file: %s", filename.c_str());
if (access(filename.c_str(), F_OK) == 0)
- return std::move(filename);
+ return filename;
}
return std::string();
}
}
}
+namespace simgrid {
+namespace mc {
+
/** \brief Finds informations about a given shared object/executable */
-std::shared_ptr<simgrid::mc::ObjectInformation> MC_find_object_info(
+std::shared_ptr<simgrid::mc::ObjectInformation> createObjectInformation(
std::vector<simgrid::xbt::VmMap> const& maps, const char *name)
{
std::shared_ptr<simgrid::mc::ObjectInformation> result =
for (auto& entry : result.get()->subprograms)
mc_post_process_scope(result.get(), &entry.second);
MC_make_functions_index(result.get());
- return std::move(result);
+ return result;
}
/*************************************************************************/
-void MC_post_process_object_info(simgrid::mc::Process* process, simgrid::mc::ObjectInformation* info)
+void postProcessObjectInformation(simgrid::mc::Process* process, simgrid::mc::ObjectInformation* info)
{
for (auto& i : info->types) {
}
}
+}
+}
+
namespace simgrid {
namespace dwarf {
