#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 "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"
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,
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;
}
}
/** Get the build-id (NT_GNU_BUILD_ID) from the ELF file
*
- * Return an empty vector is none is found.
+ * This build-id may is used to locate an external debug (DWARF) file
+ * for this ELF file.
+ *
+ * @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)
size_t phnum;
if (elf_getphdrnum (elf, &phnum) != 0)
xbt_die("Could not read program headers");
+
+ // Iterate over the program headers and find the PT_NOTE ones:
for (size_t i = 0; i < phnum; ++i) {
GElf_Phdr phdr_temp;
GElf_Phdr *phdr = gelf_getphdr(elf, i, &phdr_temp);
if (phdr->p_type != PT_NOTE)
continue;
+
Elf_Data* data = elf_getdata_rawchunk(elf, phdr->p_offset, phdr->p_filesz, ELF_T_NHDR);
+
+ // Iterate over the notes and find the NT_GNU_BUILD_ID one:
size_t pos = 0;
while (1) {
GElf_Nhdr nhdr;
size_t name_pos;
size_t desc_pos;
pos = gelf_getnote(data, pos, &nhdr, &name_pos, &desc_pos);
+ // A note is identified by a name "GNU" and a integer type within
+ // the namespace defined by this name (here NT_GNU_BUILD_ID):
if (nhdr.n_type == NT_GNU_BUILD_ID
&& nhdr.n_namesz == sizeof("GNU")
&& memcmp((char*) data->d_buf + name_pos, "GNU", sizeof("GNU")) == 0) {
+
+ // Found the NT_GNU_BUILD_ID note:
char* start = (char*) data->d_buf + desc_pos;
char* end = (char*) start + nhdr.n_descsz;
return std::vector<char>(start, end);
+
}
}
+
}
return std::vector<char>();
}
'a', 'b', 'c', 'd', 'e', 'f'
};
+/** Binary data to hexadecimal */
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] } };
}
-/** Hexadecimal representation of some binary data */
+/** Binary data to hexadecimal */
static
std::string to_hex(const char* data, std::size_t count)
{
for (int j = 0; j < 2; ++j)
res[2 * i + j] = hex_byte[j];
}
- return std::move(res);
+ return res;
}
+/** Binary data to hexadecimal */
static
std::string to_hex(std::vector<char> const& data)
{
return to_hex(data.data(), data.size());
}
+/** Base directories for external debug files */
+static
const char* debug_paths[] = {
"/usr/lib/debug/",
- "/usr/local/lib/debug/"
+ "/usr/local/lib/debug/",
};
+/** Locate an external debug file from the NT_GNU_BUILD_ID
+ *
+ * This is one of the mechanisms used for
+ * [separate debug files](https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html).
+ */
static
std::string find_by_build_id(std::vector<char> id)
{
+ 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();
}
if (elf_version(EV_CURRENT) == EV_NONE)
xbt_die("libelf initialization error");
+ // Open the ELF file:
int fd = open(info->file_name.c_str(), O_RDONLY);
if (fd < 0)
xbt_die("Could not open file %s", info->file_name.c_str());
if (kind != ELF_K_ELF)
xbt_die("Not an ELF file 2");
+ // Remember if this is a `ET_EXEC` (fixed location) or `ET_DYN` (relocatable):
Elf64_Half type = get_type(elf);
if (type == 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) {
- // This is the simple case where DWARF is located in the ELF file:
read_dwarf_info(info, dwarf);
dwarf_end(dwarf);
elf_end(elf);
}
dwarf_end(dwarf);
- // Try to find it with NT_GNU_BUILD_ID:
+ // If there was no DWARF in the file, try to find it in a separate file
+ // with NT_GNU_BUILD_ID:
std::vector<char> build_id = get_build_id(elf);
if (!build_id.empty()) {
elf_end(elf);
close(fd);
- // Find a debug file using the build id:
+ // Find the debug file using the build id:
std::string debug_file = find_by_build_id(build_id);
if (debug_file.empty()) {
std::string hex = to_hex(build_id);
}
// TODO, try to find DWARF info using debug-link.
- // Is this debug-link actually used anywhere?
+ // Is this method really used anywhere?
- // Everything failes, complain loudly:
xbt_die("Debugging information not found for %s\n"
"Try recompiling with -g\n",
info->file_name.c_str());
}
}
+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 {