-/* Copyright (c) 2008-2022. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2008-2023. 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. */
#include "src/mc/inspect/Variable.hpp"
#include "src/mc/inspect/mc_dwarf.hpp"
#include "src/mc/mc_private.hpp"
-#include "src/mc/remote/RemoteProcess.hpp"
+#include "src/mc/sosp/RemoteProcessMemory.hpp"
#include <algorithm>
#include <array>
*/
static std::uint64_t MC_dwarf_at_type(Dwarf_Die* die);
-namespace simgrid {
-namespace dwarf {
+namespace simgrid::dwarf {
enum class TagClass { Unknown, Type, Subprogram, Variable, Scope, Namespace };
return tagname(dwarf_tag(die));
}
-} // namespace dwarf
-} // namespace simgrid
+} // namespace simgrid::dwarf
// ***** Attributes
{
simgrid::mc::Type type;
type.type = dwarf_tag(die);
- type.name = std::string();
+ type.name = "";
type.element_count = -1;
// Global Offset
type.id = dwarf_dieoffset(die);
- const char* prefix = "";
+ const char* prefix;
switch (type.type) {
case DW_TAG_structure_type:
prefix = "struct ";
}
if (ns && variable->global)
- variable->name = std::string(ns) + "::" + variable->name;
+ variable->name.insert(0, std::string(ns) + "::");
// The current code needs a variable name,
// generate a fake one:
static Elf64_Half get_type(Elf* elf)
{
- const Elf64_Ehdr* ehdr64 = elf64_getehdr(elf);
- if (ehdr64)
+ if (const Elf64_Ehdr* ehdr64 = elf64_getehdr(elf))
return ehdr64->e_type;
- const Elf32_Ehdr* ehdr32 = elf32_getehdr(elf);
- if (ehdr32)
+ if (const Elf32_Ehdr* ehdr32 = elf32_getehdr(elf))
return ehdr32->e_type;
xbt_die("Could not get ELF heeader");
}
size_t length;
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)
+ if (Dwarf_Die unit_die; dwarf_offdie(dwarf, offset + length, &unit_die) != nullptr)
MC_dwarf_handle_children(info, &unit_die, &unit_die, nullptr, nullptr);
offset = next_offset;
}
* @param elf libelf handle for an ELF file
* @return build-id for this ELF file (or an empty vector if none is found)
*/
-static std::vector<char> get_build_id(Elf* elf)
+static std::vector<std::byte> get_build_id(Elf* elf)
{
#ifdef __linux
// Summary: the GNU build ID is stored in a ("GNU, NT_GNU_BUILD_ID) note
// A build ID note is identified by the pair ("GNU", NT_GNU_BUILD_ID)
// (a namespace and a type within this namespace):
if (nhdr.n_type == NT_GNU_BUILD_ID && nhdr.n_namesz == sizeof("GNU") &&
- memcmp((char*)data->d_buf + name_pos, "GNU", sizeof("GNU")) == 0) {
+ memcmp(static_cast<std::byte*>(data->d_buf) + name_pos, "GNU", sizeof("GNU")) == 0) {
XBT_DEBUG("Found GNU/NT_GNU_BUILD_ID note");
- char* start = (char*)data->d_buf + desc_pos;
- char* end = start + nhdr.n_descsz;
- return std::vector<char>(start, end);
+ std::byte* start = static_cast<std::byte*>(data->d_buf) + desc_pos;
+ std::byte* end = start + nhdr.n_descsz;
+ return std::vector<std::byte>(start, end);
}
}
}
#endif
- return std::vector<char>();
+ return std::vector<std::byte>();
}
/** Binary data to hexadecimal */
-static inline std::array<char, 2> to_hex(std::uint8_t byte)
+static inline std::array<char, 2> to_hex(std::byte byte)
{
constexpr std::array<char, 16> hexdigits{
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}};
- // Horrid double braces!
- // Apparently, this is needed in C++11 (not in C++14).
- return {{hexdigits[byte >> 4], hexdigits[byte & 0xF]}};
+ return {hexdigits[std::to_integer<unsigned>(byte >> 4)], hexdigits[std::to_integer<unsigned>(byte & std::byte{0xF})]};
}
/** Binary data to hexadecimal */
-static std::string to_hex(const char* data, std::size_t count)
+static std::string to_hex(const std::byte* data, std::size_t count)
{
std::string res;
res.resize(2 * count);
}
/** Binary data to hexadecimal */
-static std::string to_hex(std::vector<char> const& data)
+static std::string to_hex(std::vector<std::byte> const& data)
{
return to_hex(data.data(), data.size());
}
*/
// Example:
// /usr/lib/debug/.build-id/0b/dc77f1c29aea2b14ff5acd9a19ab3175ffdeae.debug
-static int find_by_build_id(std::vector<char> id)
+static int find_by_build_id(std::vector<std::byte> id)
{
std::string filename;
std::string hex = to_hex(id);
filename = std::string(debug_path) + ".build-id/" + to_hex(id.data(), 1) + '/' +
to_hex(id.data() + 1, id.size() - 1) + ".debug";
XBT_DEBUG("Checking debug file: %s", filename.c_str());
- int fd = open(filename.c_str(), O_RDONLY);
- if (fd != -1) {
+ if (int fd = open(filename.c_str(), O_RDONLY); fd != -1) {
XBT_DEBUG("Found debug file: %s\n", hex.c_str());
return fd;
}
xbt_assert(elf != nullptr && elf_kind(elf) == ELF_K_ELF, "%s is not an ELF file", info->file_name.c_str());
// Remember if this is a `ET_EXEC` (fixed location) or `ET_DYN`:
- Elf64_Half type = get_type(elf);
- if (type == ET_EXEC)
+ if (get_type(elf) == ET_EXEC)
info->flags |= simgrid::mc::ObjectInformation::Executable;
// Read DWARF debug information in the file:
- Dwarf* dwarf = dwarf_begin_elf(elf, DWARF_C_READ, nullptr);
- if (dwarf != nullptr) {
+ if (Dwarf* dwarf = dwarf_begin_elf(elf, DWARF_C_READ, nullptr)) {
read_dwarf_info(info, dwarf);
dwarf_end(dwarf);
elf_end(elf);
close(fd);
return;
}
- dwarf_end(dwarf);
// If there was no DWARF in the file, try to find it in a separate file.
// Different methods might be used to store the DWARF information:
// Try with NT_GNU_BUILD_ID: we find the build ID in the ELF file and then
// use this ID to find the file in some known locations in the filesystem.
- std::vector<char> build_id = get_build_id(elf);
- if (not build_id.empty()) {
+ if (std::vector<std::byte> build_id = get_build_id(elf); not build_id.empty()) {
elf_end(elf);
close(fd);
// Load the DWARF info from this file:
XBT_DEBUG("Load DWARF for %s", info->file_name.c_str());
- dwarf = dwarf_begin(fd, DWARF_C_READ);
+ Dwarf* dwarf = dwarf_begin(fd, DWARF_C_READ);
xbt_assert(dwarf != nullptr, "No DWARF info for %s", info->file_name.c_str());
read_dwarf_info(info, dwarf);
dwarf_end(dwarf);
// Try to find a more complete description of the type:
// We need to fix in order to support C++.
- simgrid::mc::Type** subtype = simgrid::util::find_map_ptr(info->full_types_by_name, type->name);
- if (subtype)
+ if (simgrid::mc::Type** subtype = simgrid::util::find_map_ptr(info->full_types_by_name, type->name))
type = *subtype;
return type;
}
}
}
-namespace simgrid {
-namespace mc {
+namespace simgrid::mc {
void ObjectInformation::ensure_dwarf_loaded()
{
/*************************************************************************/
-void postProcessObjectInformation(const RemoteProcess* process, ObjectInformation* info)
+void postProcessObjectInformation(const RemoteProcessMemory* process, ObjectInformation* info)
{
for (auto& [_, t] : info->types) {
Type* type = &t;
}
}
-} // namespace mc
-} // namespace simgrid
+} // namespace simgrid::mc
-namespace simgrid {
-namespace dwarf {
+namespace simgrid::dwarf {
/** Convert a DWARF register into a libunwind register
*
#endif
}
-} // namespace dwarf
-} // namespace simgrid
+} // namespace simgrid::dwarf