Google Git
Sign in
android / toolchain / jdk / jdk21 / HEAD / . / src / hotspot / share / utilities / elfFile.cpp
blob: 2e26feec9a6439bbfb7b1c5d6b168f63beb688ed [file] [log] [blame]
/*
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#include "precompiled.hpp"
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include "jvm_io.h"
#include "logging/log.hpp"
#include "memory/allocation.inline.hpp"
#include "utilities/decoder.hpp"
#include "utilities/elfFile.hpp"
#include "utilities/elfFuncDescTable.hpp"
#include "utilities/elfStringTable.hpp"
#include "utilities/elfSymbolTable.hpp"
#include "utilities/ostream.hpp"
#include <string.h>
#include <stdio.h>
#include <limits.h>
#include <new>
const char* ElfFile::USR_LIB_DEBUG_DIRECTORY = "/usr/lib/debug";
// For test only, disable elf section cache and force to read from file directly.
bool ElfFile::_do_not_cache_elf_section = false;
ElfSection::ElfSection(FILE* fd, const Elf_Shdr& hdr) : _section_data(nullptr) {
_stat = load_section(fd, hdr);
}
ElfSection::~ElfSection() {
if (_section_data != nullptr) {
os::free(_section_data);
}
}
NullDecoder::decoder_status ElfSection::load_section(FILE* const fd, const Elf_Shdr& shdr) {
memcpy((void*)&_section_hdr, (const void*)&shdr, sizeof(shdr));
if (ElfFile::_do_not_cache_elf_section) {
log_develop_debug(decoder)("Elf section cache is disabled");
return NullDecoder::no_error;
}
_section_data = os::malloc(shdr.sh_size, mtInternal);
// No enough memory for caching. It is okay, we can try to read from
// file instead.
if (_section_data == nullptr) return NullDecoder::no_error;
MarkedFileReader mfd(fd);
if (mfd.has_mark() &&
mfd.set_position(shdr.sh_offset) &&
mfd.read(_section_data, shdr.sh_size)) {
return NullDecoder::no_error;
} else {
os::free(_section_data);
_section_data = nullptr;
return NullDecoder::file_invalid;
}
}
bool FileReader::read(void* buf, size_t size) {
assert(buf != nullptr, "no buffer");
assert(size > 0, "no space");
return fread(buf, size, 1, _fd) == 1;
}
size_t FileReader::read_buffer(void* buf, size_t size) {
assert(buf != nullptr, "no buffer");
assert(size > 0, "no space");
return fread(buf, 1, size, _fd);
}
bool FileReader::set_position(long offset) {
return fseek(_fd, offset, SEEK_SET) == 0;
}
MarkedFileReader::MarkedFileReader(FILE* fd) : FileReader(fd), _marked_pos(ftell(fd)) {
}
MarkedFileReader::~MarkedFileReader() {
if (_marked_pos != -1) {
set_position(_marked_pos);
}
}
ElfFile::ElfFile(const char* filepath) :
_next(nullptr), _filepath(os::strdup(filepath)), _file(nullptr),
_symbol_tables(nullptr), _string_tables(nullptr), _shdr_string_table(nullptr), _funcDesc_table(nullptr),
_status(NullDecoder::no_error), _dwarf_file(nullptr) {
memset(&_elfHdr, 0, sizeof(_elfHdr));
if (_filepath == nullptr) {
_status = NullDecoder::out_of_memory;
} else {
_status = parse_elf(filepath);
}
}
ElfFile::~ElfFile() {
cleanup_tables();
if (_file != nullptr) {
fclose(_file);
}
if (_filepath != nullptr) {
os::free((void*) _filepath);
_filepath = nullptr;
}
if (_shdr_string_table != nullptr) {
delete _shdr_string_table;
_shdr_string_table = nullptr;
}
if (_next != nullptr) {
delete _next;
_next = nullptr;
}
if (_dwarf_file != nullptr) {
delete _dwarf_file;
_dwarf_file = nullptr;
}
}
void ElfFile::cleanup_tables() {
if (_string_tables != nullptr) {
delete _string_tables;
_string_tables = nullptr;
}
if (_symbol_tables != nullptr) {
delete _symbol_tables;
_symbol_tables = nullptr;
}
if (_funcDesc_table != nullptr) {
delete _funcDesc_table;
_funcDesc_table = nullptr;
}
}
NullDecoder::decoder_status ElfFile::parse_elf(const char* filepath) {
assert(filepath, "null file path");
_file = os::fopen(filepath, "r");
if (_file != nullptr) {
return load_tables();
} else {
return NullDecoder::file_not_found;
}
}
//Check elf header to ensure the file is valid.
bool ElfFile::is_elf_file(Elf_Ehdr& hdr) {
return (ELFMAG0 == hdr.e_ident[EI_MAG0] &&
ELFMAG1 == hdr.e_ident[EI_MAG1] &&
ELFMAG2 == hdr.e_ident[EI_MAG2] &&
ELFMAG3 == hdr.e_ident[EI_MAG3] &&
ELFCLASSNONE != hdr.e_ident[EI_CLASS] &&
ELFDATANONE != hdr.e_ident[EI_DATA]);
}
NullDecoder::decoder_status ElfFile::load_tables() {
assert(_file, "file not open");
assert(!NullDecoder::is_error(_status), "already in error");
FileReader freader(fd());
// read elf file header
if (!freader.read(&_elfHdr, sizeof(_elfHdr))) {
return NullDecoder::file_invalid;
}
// Check signature
if (!is_elf_file(_elfHdr)) {
return NullDecoder::file_invalid;
}
// walk elf file's section headers, and load string tables
Elf_Shdr shdr;
if (!freader.set_position(_elfHdr.e_shoff)) {
return NullDecoder::file_invalid;
}
for (int index = 0; index < _elfHdr.e_shnum; index ++) {
if (!freader.read(&shdr, sizeof(shdr))) {
return NullDecoder::file_invalid;
}
if (shdr.sh_type == SHT_STRTAB) {
// string tables
ElfStringTable* table = new (std::nothrow) ElfStringTable(fd(), shdr, index);
if (table == nullptr) {
return NullDecoder::out_of_memory;
}
if (index == _elfHdr.e_shstrndx) {
assert(_shdr_string_table == nullptr, "Only set once");
_shdr_string_table = table;
} else {
add_string_table(table);
}
} else if (shdr.sh_type == SHT_SYMTAB || shdr.sh_type == SHT_DYNSYM) {
// symbol tables
ElfSymbolTable* table = new (std::nothrow) ElfSymbolTable(fd(), shdr);
if (table == nullptr) {
return NullDecoder::out_of_memory;
}
add_symbol_table(table);
}
}
#if defined(PPC64) && !defined(ABI_ELFv2)
// Now read the .opd section which contains the PPC64 function descriptor table.
// The .opd section is only available on PPC64 (see for example:
// http://refspecs.linuxfoundation.org/LSB_3.1.1/LSB-Core-PPC64/LSB-Core-PPC64/specialsections.html)
// so this code should do no harm on other platforms but because of performance reasons we only
// execute it on PPC64 platforms.
// Notice that we can only find the .opd section after we have successfully read in the string
// tables in the previous loop, because we need to query the name of each section which is
// contained in one of the string tables (i.e. the one with the index m_elfHdr.e_shstrndx).
// Reset the file pointer
int sect_index = section_by_name(".opd", shdr);
if (sect_index == -1) {
return NullDecoder::file_invalid;
}
_funcDesc_table = new (std::nothrow) ElfFuncDescTable(_file, shdr, sect_index);
if (_funcDesc_table == nullptr) {
return NullDecoder::out_of_memory;
}
#endif
return NullDecoder::no_error;
}
#if defined(PPC64) && !defined(ABI_ELFv2)
int ElfFile::section_by_name(const char* name, Elf_Shdr& hdr) {
assert(name != nullptr, "No section name");
size_t len = strlen(name) + 1;
char* buf = (char*)os::malloc(len, mtInternal);
if (buf == nullptr) {
return -1;
}
assert(_shdr_string_table != nullptr, "Section header string table should be loaded");
ElfStringTable* const table = _shdr_string_table;
MarkedFileReader mfd(fd());
if (!mfd.has_mark() || !mfd.set_position(_elfHdr.e_shoff)) return -1;
int sect_index = -1;
for (int index = 0; index < _elfHdr.e_shnum; index ++) {
if (!mfd.read((void*)&hdr, sizeof(hdr))) {
break;
}
if (table->string_at(hdr.sh_name, buf, len)) {
if (strncmp(buf, name, len) == 0) {
sect_index = index;
break;
}
}
}
os::free(buf);
return sect_index;
}
#endif
bool ElfFile::decode(address addr, char* buf, int buflen, int* offset) {
// something already went wrong, just give up
if (NullDecoder::is_error(_status)) {
return false;
}
int string_table_index;
int pos_in_string_table;
int off = INT_MAX;
bool found_symbol = false;
ElfSymbolTable* symbol_table = _symbol_tables;
while (symbol_table != nullptr) {
if (symbol_table->lookup(addr, &string_table_index, &pos_in_string_table, &off, _funcDesc_table)) {
found_symbol = true;
break;
}
symbol_table = symbol_table->next();
}
if (!found_symbol) {
return false;
}
ElfStringTable* string_table = get_string_table(string_table_index);
if (string_table == nullptr) {
_status = NullDecoder::file_invalid;
return false;
}
if (offset) *offset = off;
return string_table->string_at(pos_in_string_table, buf, buflen);
}
void ElfFile::add_symbol_table(ElfSymbolTable* table) {
if (_symbol_tables == nullptr) {
_symbol_tables = table;
} else {
table->set_next(_symbol_tables);
_symbol_tables = table;
}
}
void ElfFile::add_string_table(ElfStringTable* table) {
if (_string_tables == nullptr) {
_string_tables = table;
} else {
table->set_next(_string_tables);
_string_tables = table;
}
}
ElfStringTable* ElfFile::get_string_table(int index) {
ElfStringTable* p = _string_tables;
while (p != nullptr) {
if (p->index() == index) return p;
p = p->next();
}
return nullptr;
}
// Use unified logging to report errors rather than assert() throughout this method as this code is already part of the error reporting
// and the debug symbols might be in an unsupported DWARF version or wrong format.
bool ElfFile::get_source_info(const uint32_t offset_in_library, char* filename, const size_t filename_len, int* line, bool is_pc_after_call) {
if (!load_dwarf_file()) {
// Some ELF libraries do not provide separate .debuginfo files. Check if the current ELF file has the required
// DWARF sections. If so, treat the current ELF file as DWARF file.
if (!is_valid_dwarf_file()) {
DWARF_LOG_ERROR("Failed to load DWARF file for library %s or find DWARF sections directly inside it.", _filepath);
return false;
}
DWARF_LOG_INFO("No separate .debuginfo file for library %s. It already contains the required DWARF sections.",
_filepath);
if (!create_new_dwarf_file(_filepath)) {
return false;
}
}
// Store result in filename and line pointer.
if (!_dwarf_file->get_filename_and_line_number(offset_in_library, filename, filename_len, line, is_pc_after_call)) {
DWARF_LOG_ERROR("Failed to retrieve file and line number information for %s at offset: " UINT32_FORMAT_X_0, _filepath,
offset_in_library);
return false;
}
return true;
}
bool ElfFile::is_valid_dwarf_file() const {
Elf_Shdr shdr;
return read_section_header(".debug_abbrev", shdr) && read_section_header(".debug_aranges", shdr)
&& read_section_header(".debug_info", shdr) && read_section_header(".debug_line", shdr);
}
// (1) Load the debuginfo file from the path specified in this ELF file in the .gnu_debuglink section.
// Adapted from Serviceability Agent.
bool ElfFile::load_dwarf_file() {
if (_dwarf_file != nullptr) {
return true; // Already opened.
}
DebugInfo debug_info;
if (!read_debug_info(&debug_info)) {
DWARF_LOG_DEBUG("Could not read debug info from .gnu_debuglink section");
return false;
}
DwarfFilePath dwarf_file_path(debug_info);
return load_dwarf_file_from_same_directory(dwarf_file_path)
|| load_dwarf_file_from_env_var_path(dwarf_file_path)
|| load_dwarf_file_from_debug_sub_directory(dwarf_file_path)
|| load_dwarf_file_from_usr_lib_debug(dwarf_file_path);
}
// Read .gnu_debuglink section which contains:
// Filename (null terminated) + 0-3 padding bytes (to 4 byte align) + CRC (4 bytes)
bool ElfFile::read_debug_info(DebugInfo* debug_info) const {
Elf_Shdr shdr;
if (!read_section_header(".gnu_debuglink", shdr)) {
DWARF_LOG_DEBUG("Failed to read the .gnu_debuglink header.");
return false;
}
if (shdr.sh_size % 4 != 0) {
DWARF_LOG_ERROR(".gnu_debuglink section is not 4 byte aligned (i.e. file is corrupted)");
return false;
}
MarkedFileReader mfd(fd());
if (!mfd.has_mark() || !mfd.set_position(_elfHdr.e_shoff)) {
return false;
}
uint64_t filename_max_len = shdr.sh_size - DebugInfo::CRC_LEN;
mfd.set_position(shdr.sh_offset);
if (!mfd.read(&debug_info->_dwarf_filename, filename_max_len)) {
return false;
}
if (debug_info->_dwarf_filename[filename_max_len - 1] != '\0') {
// Filename not null-terminated (i.e. overflowed).
DWARF_LOG_ERROR("Dwarf filename is not null-terminated");
return false;
}
return mfd.read(&debug_info->_crc, DebugInfo::CRC_LEN);
}
bool ElfFile::DwarfFilePath::set(const char* src) {
int bytes_written = jio_snprintf(_path, MAX_DWARF_PATH_LENGTH, "%s", src);
if (bytes_written < 0 || bytes_written >= MAX_DWARF_PATH_LENGTH) {
DWARF_LOG_ERROR("Dwarf file path buffer is too small");
return false;
}
update_null_terminator_index();
return check_valid_path(); // Sanity check
}
bool ElfFile::DwarfFilePath::set_after_last_slash(const char* src) {
char* last_slash = strrchr(_path, *os::file_separator());
if (last_slash == nullptr) {
// Should always find a slash.
return false;
}
uint16_t index_after_slash = (uint16_t)(last_slash + 1 - _path);
return copy_to_path_index(index_after_slash, src);
}
bool ElfFile::DwarfFilePath::append(const char* src) {
return copy_to_path_index(_null_terminator_index, src);
}
bool ElfFile::DwarfFilePath::copy_to_path_index(uint16_t index_in_path, const char* src) {
if (index_in_path >= MAX_DWARF_PATH_LENGTH - 1) {
// Should not override '\0' at _path[MAX_DWARF_PATH_LENGTH - 1]
DWARF_LOG_ERROR("Dwarf file path buffer is too small");
return false;
}
uint16_t max_len = MAX_DWARF_PATH_LENGTH - index_in_path;
int bytes_written = jio_snprintf(_path + index_in_path, max_len, "%s", src);
if (bytes_written < 0 || bytes_written >= max_len) {
DWARF_LOG_ERROR("Dwarf file path buffer is too small");
return false;
}
update_null_terminator_index();
return check_valid_path(); // Sanity check
}
// Try to load the dwarf file from the same directory as the library file.
bool ElfFile::load_dwarf_file_from_same_directory(DwarfFilePath& dwarf_file_path) {
if (!dwarf_file_path.set(_filepath)
|| !dwarf_file_path.set_filename_after_last_slash()) {
return false;
}
return open_valid_debuginfo_file(dwarf_file_path);
}
// Try to load the dwarf file from a user specified path in environmental variable _JVM_DWARF_PATH.
bool ElfFile::load_dwarf_file_from_env_var_path(DwarfFilePath& dwarf_file_path) {
const char* dwarf_path_from_env = ::getenv("_JVM_DWARF_PATH");
if (dwarf_path_from_env != nullptr) {
DWARF_LOG_DEBUG("_JVM_DWARF_PATH: %s", dwarf_path_from_env);
return (load_dwarf_file_from_env_path_folder(dwarf_file_path, dwarf_path_from_env, "/lib/server/")
|| load_dwarf_file_from_env_path_folder(dwarf_file_path, dwarf_path_from_env, "/lib/")
|| load_dwarf_file_from_env_path_folder(dwarf_file_path, dwarf_path_from_env, "/bin/")
|| load_dwarf_file_from_env_path_folder(dwarf_file_path, dwarf_path_from_env, "/"));
}
return false;
}
bool ElfFile::load_dwarf_file_from_env_path_folder(DwarfFilePath& dwarf_file_path, const char* dwarf_path_from_env,
const char* folder) {
if (!dwarf_file_path.set(dwarf_path_from_env)
|| !dwarf_file_path.append(folder)
|| !dwarf_file_path.append(dwarf_file_path.filename())) {
DWARF_LOG_ERROR("Dwarf file path buffer is too small");
return false;
}
return open_valid_debuginfo_file(dwarf_file_path);
}
// Try to load the dwarf file from a subdirectory named .debug within the directory of the library file.
bool ElfFile::load_dwarf_file_from_debug_sub_directory(DwarfFilePath& dwarf_file_path) {
if (!dwarf_file_path.set(_filepath)
|| !dwarf_file_path.set_after_last_slash(".debug/")
|| !dwarf_file_path.append(dwarf_file_path.filename())) {
DWARF_LOG_ERROR("Dwarf file path buffer is too small");
return false;
}
return open_valid_debuginfo_file(dwarf_file_path);
}
// Try to load the dwarf file from /usr/lib/debug + the full pathname.
bool ElfFile::load_dwarf_file_from_usr_lib_debug(DwarfFilePath& dwarf_file_path) {
if (!dwarf_file_path.set(USR_LIB_DEBUG_DIRECTORY)
|| !dwarf_file_path.append(_filepath)
|| !dwarf_file_path.set_filename_after_last_slash()) {
DWARF_LOG_ERROR("Dwarf file path buffer is too small");
return false;
}
return open_valid_debuginfo_file(dwarf_file_path);
}
bool ElfFile::read_section_header(const char* name, Elf_Shdr& hdr) const {
if (_shdr_string_table == nullptr) {
assert(false, "section header string table should be loaded");
return false;
}
const uint8_t buf_len = 24;
char buf[buf_len];
size_t len = strlen(name) + 1;
if (len > buf_len) {
DWARF_LOG_ERROR("Section header name buffer is too small: Required: %zu, Found: %d", len, buf_len);
return false;
}
MarkedFileReader mfd(fd());
if (!mfd.has_mark() || !mfd.set_position(_elfHdr.e_shoff)) {
return false;
}
for (int index = 0; index < _elfHdr.e_shnum; index++) {
if (!mfd.read((void*)&hdr, sizeof(hdr))) {
return false;
}
if (_shdr_string_table->string_at(hdr.sh_name, buf, buf_len)) {
if (strncmp(buf, name, buf_len) == 0) {
return true;
}
}
}
return false;
}
// Taken from https://sourceware.org/gdb/current/onlinedocs/gdb/Separate-Debug-Files.html#Separate-Debug-Files
static const uint32_t crc32_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
0x2d02ef8d
};
bool ElfFile::open_valid_debuginfo_file(const DwarfFilePath& dwarf_file_path) {
if (_dwarf_file != nullptr) {
// Already opened.
return true;
}
const char* filepath = dwarf_file_path.path();
FILE* file = fopen(filepath, "r");
if (file == nullptr) {
DWARF_LOG_DEBUG("Could not open dwarf file %s (%s)", filepath, os::strerror(errno));
return false;
}
uint32_t file_crc = get_file_crc(file);
fclose(file); // Close it here to reopen it again when the DwarfFile object is created below.
if (dwarf_file_path.crc() != file_crc) {
// Must be equal, otherwise the file is corrupted.
DWARF_LOG_ERROR("CRC did not match. Expected: " INT32_FORMAT_X_0 ", found: " INT32_FORMAT_X_0, dwarf_file_path.crc(),
file_crc);
return false;
}
return create_new_dwarf_file(filepath);
}
uint32_t ElfFile::get_file_crc(FILE* const file) {
uint32_t file_crc = 0;
uint8_t buffer[8 * 1024];
MarkedFileReader reader(file);
while (true) {
size_t len = reader.read_buffer(buffer, sizeof(buffer));
if (len == 0) {
break;
}
file_crc = gnu_debuglink_crc32(file_crc, buffer, len);
}
return file_crc;
}
// The CRC used in gnu_debuglink, retrieved from
// http://sourceware.org/gdb/current/onlinedocs/gdb/Separate-Debug-Files.html#Separate-Debug-Files.
uint32_t ElfFile::gnu_debuglink_crc32(uint32_t crc, uint8_t* buf, const size_t len) {
crc = ~crc;
for (uint8_t* end = buf + len; buf < end; buf++) {
crc = crc32_table[(crc ^ *buf) & 0xffu] ^ (crc >> 8u);
}
return ~crc;
}
bool ElfFile::create_new_dwarf_file(const char* filepath) {
DWARF_LOG_SUMMARY("Open DWARF file: %s", filepath);
_dwarf_file = new (std::nothrow) DwarfFile(filepath);
if (_dwarf_file == nullptr) {
DWARF_LOG_ERROR("Failed to create new DwarfFile object for %s.", _filepath);
return false;
}
if (!_dwarf_file->is_valid_dwarf_file()) {
DWARF_LOG_ERROR("Did not find required DWARF sections in %s", filepath);
return false;
}
return true;
}
// Starting point of reading line number and filename information from the DWARF file.
bool DwarfFile::get_filename_and_line_number(const uint32_t offset_in_library, char* filename, const size_t filename_len,
int* line, const bool is_pc_after_call) {
DebugAranges debug_aranges(this);
uint32_t compilation_unit_offset = 0; // 4-bytes for 32-bit DWARF
if (!debug_aranges.find_compilation_unit_offset(offset_in_library, &compilation_unit_offset)) {
DWARF_LOG_ERROR("Failed to find .debug_info offset for the compilation unit.");
return false;
}
DWARF_LOG_INFO(".debug_info offset: " INT32_FORMAT_X_0, compilation_unit_offset);
CompilationUnit compilation_unit(this, compilation_unit_offset);
uint32_t debug_line_offset = 0; // 4-bytes for 32-bit DWARF
if (!compilation_unit.find_debug_line_offset(&debug_line_offset)) {
DWARF_LOG_ERROR("Failed to find .debug_line offset for the line number program.");
return false;
}
DWARF_LOG_INFO(".debug_line offset: " INT32_FORMAT_X_0, debug_line_offset);
LineNumberProgram line_number_program(this, offset_in_library, debug_line_offset, is_pc_after_call);
if (!line_number_program.find_filename_and_line_number(filename, filename_len, line)) {
DWARF_LOG_ERROR("Failed to process the line number program correctly.");
return false;
}
return true;
}
// (2) The .debug_aranges section contains a number of entries/sets. Each set contains one or multiple address range descriptors of the
// form [beginning_address, beginning_address+length). Start reading these sets and their descriptors until we find one that contains
// 'offset_in_library'. Read the debug_info_offset field from the header of this set which defines the offset for the compilation unit.
// This process is described in section 6.1.2 of the DWARF 4 spec.
bool DwarfFile::DebugAranges::find_compilation_unit_offset(const uint32_t offset_in_library, uint32_t* compilation_unit_offset) {
if (!read_section_header()) {
DWARF_LOG_ERROR("Failed to read a .debug_aranges header.");
return false;
}
DebugArangesSetHeader set_header;
bool found_matching_set = false;
while (_reader.has_bytes_left()) {
// Read multiple sets and therefore multiple headers.
if (!read_set_header(set_header)) {
DWARF_LOG_ERROR("Failed to read a .debug_aranges header.");
return false;
}
if (!read_address_descriptors(set_header, offset_in_library, found_matching_set)) {
return false;
}
if (found_matching_set) {
// Found the correct set, read the debug_info_offset from the header of this set.
DWARF_LOG_INFO(".debug_aranges offset: " UINT32_FORMAT, (uint32_t)_reader.get_position());
*compilation_unit_offset = set_header._debug_info_offset;
return true;
}
}
assert(false, "No address descriptor found containing offset_in_library.");
return false;
}
bool DwarfFile::DebugAranges::read_section_header() {
Elf_Shdr shdr;
if (!_dwarf_file->read_section_header(".debug_aranges", shdr)) {
return false;
}
_section_start_address = shdr.sh_offset;
_reader.set_max_pos(shdr.sh_offset + shdr.sh_size);
return _reader.set_position(shdr.sh_offset);
}
// Parse set header as specified in section 6.1.2 of the DWARF 4 spec.
bool DwarfFile::DebugAranges::read_set_header(DebugArangesSetHeader& header) {
if (!_reader.read_dword(&header._unit_length) || header._unit_length == 0xFFFFFFFF) {
// For 64-bit DWARF, the first 32-bit value is 0xFFFFFFFF. The current implementation only supports 32-bit DWARF
// format since GCC only emits 32-bit DWARF.
DWARF_LOG_ERROR("64-bit DWARF is not supported for .debug_aranges")
return false;
}
_entry_end = _reader.get_position() + header._unit_length;
if (!_reader.read_word(&header._version) || header._version != 2) {
// DWARF 4 uses version 2 as specified in Appendix F of the DWARF 4 spec.
DWARF_LOG_ERROR(".debug_aranges in unsupported DWARF version %" PRIu16, header._version)
return false;
}
if (!_reader.read_dword(&header._debug_info_offset)) {
return false;
}
if (!_reader.read_byte(&header._address_size) || header._address_size != DwarfFile::ADDRESS_SIZE) {
// Addresses must be either 4 bytes for 32-bit architectures or 8 bytes for 64-bit architectures.
DWARF_LOG_ERROR(".debug_aranges specifies wrong address size %" PRIu8, header._address_size);
return false;
}
if (!_reader.read_byte(&header._segment_size) || header._segment_size != 0) {
// Segment size should be 0.
DWARF_LOG_ERROR(".debug_aranges segment size is non-zero: %" PRIu8, header._segment_size);
return false;
}
// We must align to twice the address size.
uint8_t alignment = DwarfFile::ADDRESS_SIZE * 2;
uint8_t padding = alignment - (_reader.get_position() - _section_start_address) % alignment;
return _reader.move_position(padding);
}
bool DwarfFile::DebugAranges::read_address_descriptors(const DwarfFile::DebugAranges::DebugArangesSetHeader& header,
const uint32_t offset_in_library, bool& found_matching_set) {
AddressDescriptor descriptor;
do {
if (!read_address_descriptor(descriptor)) {
return false;
}
if (does_match_offset(offset_in_library, descriptor)) {
found_matching_set = true;
return true;
}
} while (!is_terminating_entry(header, descriptor) && _reader.has_bytes_left());
// Set does not match offset_in_library. Continue with next.
return true;
}
bool DwarfFile::DebugAranges::read_address_descriptor(AddressDescriptor& descriptor) {
return _reader.read_address_sized(&descriptor.beginning_address)
&& _reader.read_address_sized(&descriptor.range_length);
}
bool DwarfFile::DebugAranges::does_match_offset(const uint32_t offset_in_library, const AddressDescriptor& descriptor) {
return descriptor.beginning_address <= offset_in_library
&& offset_in_library < descriptor.beginning_address + descriptor.range_length;
}
bool DwarfFile::DebugAranges::is_terminating_entry(const DwarfFile::DebugAranges::DebugArangesSetHeader& header,
const AddressDescriptor& descriptor) {
bool is_terminating = _reader.get_position() >= _entry_end;
assert(!is_terminating || (descriptor.beginning_address == 0 && descriptor.range_length == 0),
"a terminating entry needs a pair of zero");
return is_terminating;
}
// Find the .debug_line offset for the line number program by reading from the .debug_abbrev and .debug_info section.
bool DwarfFile::CompilationUnit::find_debug_line_offset(uint32_t* debug_line_offset) {
// (3a,b)
if (!read_header()) {
DWARF_LOG_ERROR("Failed to read the compilation unit header.");
return false;
}
// (3c) Read the abbreviation code immediately following the compilation unit header which is an offset to the
// correct abbreviation table in .debug_abbrev for this compilation unit.
uint64_t abbrev_code;
if (!_reader.read_uleb128(&abbrev_code)) {
return false;
}
DebugAbbrev debug_abbrev(_dwarf_file, this);
if (!debug_abbrev.read_section_header(_header._debug_abbrev_offset)) {
DWARF_LOG_ERROR("Failed to read the .debug_abbrev header at " UINT32_FORMAT_X_0, _header._debug_abbrev_offset);
return false;
}
if (!debug_abbrev.find_debug_line_offset(abbrev_code)) {
return false;
}
*debug_line_offset = _debug_line_offset; // Result was stored in _debug_line_offset.
return true;
}
// (3a) Parse header as specified in section 7.5.1.1 of the DWARF 4 spec.
bool DwarfFile::CompilationUnit::read_header() {
Elf_Shdr shdr;
if (!_dwarf_file->read_section_header(".debug_info", shdr)) {
DWARF_LOG_ERROR("Failed to read the .debug_info section header.");
return false;
}
if (!_reader.set_position(shdr.sh_offset + _compilation_unit_offset)) {
return false;
}
if (!_reader.read_dword(&_header._unit_length) || _header._unit_length == 0xFFFFFFFF) {
// For 64-bit DWARF, the first 32-bit value is 0xFFFFFFFF. The current implementation only supports 32-bit DWARF
// format since GCC only emits 32-bit DWARF.
DWARF_LOG_ERROR("64-bit DWARF is not supported for .debug_info")
return false;
}
if (!_reader.read_word(&_header._version) || _header._version != 4) {
// DWARF 4 uses version 4 as specified in Appendix F of the DWARF 4 spec.
DWARF_LOG_ERROR(".debug_info in unsupported DWARF version %" PRIu16, _header._version)
return false;
}
// (3b) Offset into .debug_abbrev section.
if (!_reader.read_dword(&_header._debug_abbrev_offset)) {
return false;
}
if (!_reader.read_byte(&_header._address_size) || _header._address_size != DwarfFile::ADDRESS_SIZE) {
// Addresses must be either 4 bytes for 32-bit architectures or 8 bytes for 64-bit architectures.
DWARF_LOG_ERROR(".debug_info specifies wrong address size %" PRIu8, _header._address_size);
return false;
}
// Add because _unit_length is not included.
_reader.set_max_pos(_reader.get_position() + _header._unit_length + 4);
return true;
}
bool DwarfFile::DebugAbbrev::read_section_header(uint32_t debug_abbrev_offset) {
Elf_Shdr shdr;
if (!_dwarf_file->read_section_header(".debug_abbrev", shdr)) {
return false;
}
_reader.set_max_pos(shdr.sh_offset + shdr.sh_size);
if (!_reader.set_position(shdr.sh_offset + debug_abbrev_offset)) {
return false;
}
return true;
}
// (3d) The abbreviations table for a compilation unit consists of a series of abbreviation declarations. Each declaration
// specifies an abbrev code and a tag. Parse all declarations until we find the declaration which matches 'abbrev_code'.
// Read the attribute values from the compilation unit in .debug_info by using the format described in the declaration.
// This process is described in section 7.5 and 7.5.3 of the DWARF 4 spec.
bool DwarfFile::DebugAbbrev::find_debug_line_offset(const uint64_t abbrev_code) {
DWARF_LOG_TRACE("Series of declarations [code, tag]:");
AbbreviationDeclaration declaration;
while (_reader.has_bytes_left()) {
if (!read_declaration(declaration)) {
return false;
}
DWARF_LOG_TRACE(" Series of attributes [name, form]:");
if (declaration._abbrev_code == abbrev_code) {
// Found the correct declaration.
if (is_wrong_or_unsupported_format(declaration)) {
return false;
}
DWARF_LOG_INFO(".debug_abbrev offset: " UINT32_FORMAT_X_0, (uint32_t)_reader.get_position());
DWARF_LOG_TRACE(" Read the following attribute values from compilation unit:");
return read_attribute_specifications(true);
} else {
// Not the correct declaration. Read its attributes and continue with the next declaration.
if (!read_attribute_specifications(false)) {
return false;
}
}
}
assert(false, ".debug_line offset not found");
return false;
}
bool DwarfFile::DebugAbbrev::read_declaration(DwarfFile::DebugAbbrev::AbbreviationDeclaration& declaration) {
if (!_reader.read_uleb128(&declaration._abbrev_code)) {
return false;
}
if (declaration._abbrev_code == 0) {
// Reached the end of the abbreviation declarations for this compilation unit.
DWARF_LOG_ERROR("abbrev_code not found in any declaration");
return false;
}
if (!_reader.read_uleb128(&declaration._tag) || !_reader.read_byte(&declaration._has_children)) {
return false;
}
DWARF_LOG_TRACE("Code: " UINT64_FORMAT_X ", Tag: " UINT64_FORMAT_X, declaration._abbrev_code, declaration._tag);
return true;
}
bool DwarfFile::DebugAbbrev::is_wrong_or_unsupported_format(const DwarfFile::DebugAbbrev::AbbreviationDeclaration& declaration) {
if (declaration._tag != DW_TAG_compile_unit) {
// Is not DW_TAG_compile_unit as specified in Figure 18 in section 7.5 of the DWARF 4 spec. It could also
// be DW_TAG_partial_unit (0x3c) which is currently not supported by this parser.
DWARF_LOG_ERROR("Found unsupported tag in compilation unit: " UINT64_FORMAT_X, declaration._tag);
return true;
}
if (declaration._has_children != DW_CHILDREN_yes) {
DWARF_LOG_ERROR("Must have children but none specified");
return true;
}
return false;
}
// Read the attribute names and forms which define the actual attribute values that follow the abbrev code in the compilation unit. All
// attributes need to be read from the compilation unit until we reach the DW_AT_stmt_list attribute which specifies the offset for the
// line number program into the .debug_line section. The offset is stored in the _debug_line_offset field of the compilation unit.
bool DwarfFile::DebugAbbrev::read_attribute_specifications(const bool is_DW_TAG_compile_unit) {
AttributeSpecification attribute_specification;
while (_reader.has_bytes_left()) {
if (!read_attribute_specification(attribute_specification)) {
return false;
}
if (is_terminating_specification(attribute_specification)) {
// Parsed all attributes of this declaration.
if (is_DW_TAG_compile_unit) {
DWARF_LOG_ERROR("Did not find DW_AT_stmt_list in .debug_abbrev");
return false;
} else {
// Continue with next declaration if this was not DW_TAG_compile_unit.
return true;
}
}
if (is_DW_TAG_compile_unit) {
// Read attribute from compilation unit
if (attribute_specification._name == DW_AT_stmt_list) {
// This attribute represents the .debug_line offset. Read it and then stop parsing.
return _compilation_unit->read_attribute_value(attribute_specification._form, true);
} else {
// Not DW_AT_stmt_list, read it and continue with the next attribute.
if (!_compilation_unit->read_attribute_value(attribute_specification._form, false)) {
return false;
}
}
}
}
assert(false, ".debug_abbrev section appears to be corrupted");
return false;
}
bool DwarfFile::DebugAbbrev::read_attribute_specification(DwarfFile::DebugAbbrev::AttributeSpecification& specification) {
bool result = _reader.read_uleb128(&specification._name) && _reader.read_uleb128(&specification._form);
DWARF_LOG_TRACE(" Name: " UINT64_FORMAT_X ", Form: " UINT64_FORMAT_X,
specification._name, specification._form);
return result;
}
bool DwarfFile::DebugAbbrev::is_terminating_specification(const DwarfFile::DebugAbbrev::AttributeSpecification& specification) {
return specification._name == 0 && specification._form == 0;
}
// (3e) Read the actual attribute values from the compilation unit in the .debug_info section. Each attribute has an encoding
// that specifies which values need to be read for it. This is specified in section 7.5.4 of the DWARF 4 spec.
// If is_DW_AT_stmt_list_attribute is:
// - False: Ignore the read attribute value.
// - True: We are going to read the attribute value of the DW_AT_stmt_list attribute which specifies the offset into the
// .debug_line section for the line number program. Store this offset in the _debug_line_offset field.
bool DwarfFile::CompilationUnit::read_attribute_value(const uint64_t attribute_form, const bool is_DW_AT_stmt_list_attribute) {
// Reset to the stored _cur_pos of the reader since the DebugAbbrev reader changed the index into the file with its reader.
_reader.update_to_stored_position();
uint8_t next_byte = 0;
uint16_t next_word = 0;
uint32_t next_dword = 0;
uint64_t next_qword = 0;
switch (attribute_form) {
case DW_FORM_addr:
// Move position by the size of an address.
_reader.move_position(DwarfFile::ADDRESS_SIZE);
break;
case DW_FORM_block2:
// New position: length + data length (next_word)
if (!_reader.read_word(&next_word) || !_reader.move_position(next_word)) {
return false;
}
break;
case DW_FORM_block4:
// New position: length + data length (next_dword)
if (!_reader.read_dword(&next_dword) || !_reader.move_position(next_dword)) {
return false;
}
break;
case DW_FORM_data2:
case DW_FORM_ref2:
if (!_reader.move_position(2)) {
return false;
}
break;
case DW_FORM_data4:
case DW_FORM_strp: // 4 bytes in 32-bit DWARF
case DW_FORM_ref_addr: // second type of reference: 4 bytes in 32-bit DWARF
case DW_FORM_ref4:
if (!_reader.move_position(4)) {
return false;
}
break;
case DW_FORM_data8:
case DW_FORM_ref8:
case DW_FORM_ref_sig8: // 64-bit type signature
if (!_reader.move_position(8)) {
return false;
}
break;
case DW_FORM_string:
if (!_reader.read_string()) {
return false;
}
break;
case DW_FORM_block:
case DW_FORM_exprloc:
// New position: length + data length (next_qword).
if (!_reader.read_uleb128(&next_qword) || !_reader.move_position(next_qword)) {
return false;
}
break;
case DW_FORM_block1:
// New position: length + data length (next_byte).
if (!_reader.read_byte(&next_byte) || !_reader.move_position(next_byte)) {
return false;
}
break;
case DW_FORM_data1:
case DW_FORM_ref1:
case DW_FORM_flag:
case DW_FORM_flag_present:
if (!_reader.move_position(1)) {
return false;
}
break;
case DW_FORM_sdata:
case DW_FORM_udata:
case DW_FORM_ref_udata:
if (!_reader.read_uleb128(&next_qword)) {
return false;
}
break;
case DW_FORM_indirect:
// Should not be used and therefore is not supported by this parser.
DWARF_LOG_ERROR("DW_FORM_indirect is not supported.");
return false;
case DW_FORM_sec_offset:
if (is_DW_AT_stmt_list_attribute) {
// DW_AT_stmt_list has the DW_FORM_sec_offset attribute encoding. Store the result in _debug_line_offset.
// 4 bytes for 32-bit DWARF.
DWARF_LOG_TRACE(" Name: DW_AT_stmt_list, Form: DW_FORM_sec_offset");
DWARF_LOG_TRACE(" Reading .debug_line offset from compilation unit at " UINT32_FORMAT_X_0,
(uint32_t)_reader.get_position());
if (!_reader.read_dword(&_debug_line_offset)) {
return false;
}
break;
} else {
if (!_reader.move_position(DwarfFile::DWARF_SECTION_OFFSET_SIZE)) {
return false;
}
break;
}
default:
assert(false, "Unknown DW_FORM_* attribute encoding.");
return false;
}
// Reset the index into the file to the original position where the DebugAbbrev reader stopped reading before calling this method.
_reader.reset_to_previous_position();
return true;
}
bool DwarfFile::LineNumberProgram::find_filename_and_line_number(char* filename, const size_t filename_len, int* line) {
if (!read_header()) {
DWARF_LOG_ERROR("Failed to parse the line number program header correctly.");
return false;
}
return run_line_number_program(filename, filename_len, line);
}
// Parsing header as specified in section 6.2.4 of DWARF 4 spec. We do not read the file_names field, yet.
bool DwarfFile::LineNumberProgram::read_header() {
Elf_Shdr shdr;
if (!_dwarf_file->read_section_header(".debug_line", shdr)) {
DWARF_LOG_ERROR("Failed to read the .debug_line section header.");
return false;
}
if (!_reader.set_position(shdr.sh_offset + _debug_line_offset)) {
return false;
}
if (!_reader.read_dword(&_header._unit_length) || _header._unit_length == 0xFFFFFFFF) {
// For 64-bit DWARF, the first 32-bit value is 0xFFFFFFFF. The current implementation only supports 32-bit DWARF
// format since GCC only emits 32-bit DWARF.
DWARF_LOG_ERROR("64-bit DWARF is not supported for .debug_line")
return false;
}
if (!_reader.read_word(&_header._version) || _header._version < 2 || _header._version > 4) {
// DWARF 3 uses version 3 and DWARF 4 uses version 4 as specified in Appendix F of the DWARF 3 and 4 spec, respectively.
// For some reason, GCC is not following the standard here. While GCC emits DWARF 4 for the other parsed sections,
// it chooses a different DWARF standard for .debug_line based on the GCC version:
// - GCC 8 and earlier: .debug_line is in DWARF 2 format (= version 2).
// - GCC 9 and 10: .debug_line is in DWARF 3 format (= version 3).
// - GCC 11: .debug_line is in DWARF 4 format (= version 4).
DWARF_LOG_ERROR(".debug_line in unsupported DWARF version %" PRIu16, _header._version)
return false;
}
if (!_reader.read_dword(&_header._header_length)) {
return false;
}
// To ensure not to read too many bytes in case of file corruption when reading the path_names field.
_reader.set_max_pos(_reader.get_position() + _header._header_length);
if (!_reader.read_byte(&_header._minimum_instruction_length)) {
return false;
}
if (_header._version == 4) {
if (!_reader.read_byte(&_header._maximum_operations_per_instruction)) {
return false;
}
}
if (!_reader.read_byte(&_header._default_is_stmt)) {
return false;
}
if (!_reader.read_byte(&_header._line_base)) {
return false;
}
if (!_reader.read_byte(&_header._line_range)) {
return false;
}
if (!_reader.read_byte(&_header._opcode_base) || _header._opcode_base - 1 != 12) {
// There are 12 standard opcodes for DWARF 3 and 4.
DWARF_LOG_ERROR("Wrong number of opcodes: %" PRIu8, _header._opcode_base)
return false;
}
for (uint8_t i = 0; i < _header._opcode_base - 1; i++) {
if (!_reader.read_byte(&_header._standard_opcode_lengths[i])) {
return false;
}
}
// Read field include_directories which is a sequence of path names. These are terminated by a single null byte.
// We do not care about them, just read the strings and move on.
while (_reader.read_string()) { }
// Delay reading file_names until we found the correct file index in the line number program. Store the position where
// the file names start to parse them later. We directly jump to the line number program which starts at offset
// header_size (=HEADER_DESCRIPTION_BYTES + _header_length) + _debug_line_offset
_header._file_names_offset = _reader.get_position();
uint32_t header_size = LineNumberProgramHeader::HEADER_DESCRIPTION_BYTES + _header._header_length;
if (!_reader.set_position(shdr.sh_offset + header_size + _debug_line_offset)) {
return false;
}
// Now reset the max position to where the line number information for this compilation unit ends (i.e. where the state
// machine gets terminated). Add 4 bytes to the offset because the size of the _unit_length field is not included in this
// value.
_reader.set_max_pos(shdr.sh_offset + _debug_line_offset + _header._unit_length + 4);
return true;
}
// Create the line number information matrix as described in section 6.2 of the DWARF 4 spec. Try to find the correct entry
// by comparing the address register belonging to each matrix row with _offset_in_library. Once it is found, we can read
// the line number from the line register and the filename by parsing the file_names list from the header until we reach
// the correct filename as specified by the file register.
//
// If space was not a problem, the .debug_line section could provide a large matrix that contains an entry for each
// compiler instruction that contains the line number, the column number, the filename etc. But that's impractical.
// Two techniques optimize such a matrix:
// (1) If two offsets share the same file, line and column (and discriminator) information, the row is dropped.
// (2) We store a stream of bytes that represent opcodes to be executed in a well-defined state machine language
// instead of actually storing the entire matrix row by row.
//
// Let's consider a simple example:
// 25: int iFld = 42;
// 26:
// 27: void bar(int i) {
// 28: }
// 29:
// 30: void foo() {
// 31: bar(*iFld);
// 32: }
//
// Disassembly of foo() with source code:
// 30: void foo() {
// 0x55d132: 55 push rbp
// 0x55d133: 48 89 e5 mov rbp,rsp
// 31: bar(*iFld);
// 0x55d136: 48 8b 05 b3 ee e8 01 mov rax,QWORD PTR [rip+0x1e8eeb3] # 23ebff0 <iFld>
// 0x55d13d: 8b 00 mov eax,DWORD PTR [rax]
// 0x55d13f: 89 c7 mov edi,eax
// 0x55d141: e8 e2 ff ff ff call 55d128 <_Z3bari>
// 32: }
// 0x55d146: 90 nop
// 0x55d147: 5d pop rbp
// 0x55d148: c3 ret
//
// This would produce the following matrix for foo() where duplicated lines (0x55d133, 0x55d13d, 0x55d13f) were removed
// according to (1):
// Address: Line: Column: File:
// 0x55d132 30 12 1
// 0x55d136 31 6 1
// 0x55d146 32 1 1
//
// When trying to get the line number for a PC, which is translated into an offset address x into the library file, we can either:
// - Directly find the last entry in the matrix for which address == x (there could be multiple entries with the same address).
// - If there is no matching address for x:
// 1. Find two consecutive entries in the matrix for which: address_entry_1 < x < address_entry_2.
// 2. Then take the entry of address_entry_1.
// E.g. x = 0x55d13f -> 0x55d136 < 0x55d13f < 0x55d146 -> Take entry 0x55d136.
//
// Enable logging with debug level to print the generated line number information matrix.
bool DwarfFile::LineNumberProgram::run_line_number_program(char* filename, const size_t filename_len, int* line) {
DWARF_LOG_DEBUG("");
DWARF_LOG_DEBUG("Line Number Information Matrix");
DWARF_LOG_DEBUG("------------------------------");
#ifndef _LP64
DWARF_LOG_DEBUG("Address: Line: Column: File:");
#else
DWARF_LOG_DEBUG("Address: Line: Column: File:");
#endif
_state = new (std::nothrow) LineNumberProgramState(_header);
if (_state == nullptr) {
DWARF_LOG_ERROR("Failed to create new LineNumberProgramState object");
return false;
}
uintptr_t previous_address = 0;
uint32_t previous_file = 0;
uint32_t previous_line = 0;
bool found_entry = false;
bool candidate = false;
bool first_in_sequence = true;
while (_reader.has_bytes_left()) {
if (!apply_opcode()) {
assert(false, "Could not apply opcode");
return false;
}
if (_state->_append_row) {
// Append a new line to the line number information matrix.
if (_state->_first_entry_in_sequence) {
// First entry in sequence: Check if _offset_in_library >= _state->address. If not, then all following entries
// belonging to this sequence cannot match our _offset_in_library because the addresses are always increasing
// in a sequence.
_state->_can_sequence_match_offset = _offset_in_library >= _state->_address;
_state->_first_entry_in_sequence = false;
}
if (does_offset_match_entry(previous_address, previous_file, previous_line)) {
// We are using an int for the line number which should never be larger than INT_MAX for any files.
*line = (int)_state->_line;
return get_filename_from_header(_state->_file, filename, filename_len);
}
// We do not actually store the matrix while searching the correct entry. Enable logging to print/debug it.
DWARF_LOG_DEBUG(INTPTR_FORMAT " %-5u %-3u %-4u",
_state->_address, _state->_line, _state->_column, _state->_file);
previous_file = _state->_file;
previous_line = _state->_line;
previous_address = _state->_address;
_state->_append_row = false;
if (_state->_do_reset) {
// Current sequence terminated.
_state->reset_fields();
}
}
}
assert(false, "Did not find an entry in the line number information matrix that matches " UINT32_FORMAT_X_0, _offset_in_library);
return false;
}
// Apply next opcode to update the state machine.
bool DwarfFile::LineNumberProgram::apply_opcode() {
uint8_t opcode;
if (!_reader.read_byte(&opcode)) {
return false;
}
DWARF_LOG_TRACE(" Opcode: 0x%02x ", opcode);
if (opcode == 0) {
// Extended opcodes start with a zero byte.
if (!apply_extended_opcode()) {
assert(false, "Could not apply extended opcode");
return false;
}
} else if (opcode <= 12) {
// 12 standard opcodes in DWARF 3 and 4.
if (!apply_standard_opcode(opcode)) {
assert(false, "Could not apply standard opcode");
return false;
}
} else {
// Special opcodes range from 13 until 255.
apply_special_opcode(opcode);
}
return true;
}
// Specified in section 6.2.5.3 of the DWARF 4 spec.
bool DwarfFile::LineNumberProgram::apply_extended_opcode() {
uint64_t extended_opcode_length; // Does not include the already written zero byte and the length leb128.
uint8_t extended_opcode;
if (!_reader.read_uleb128(&extended_opcode_length) || !_reader.read_byte(&extended_opcode)) {
return false;
}
switch (extended_opcode) {
case DW_LNE_end_sequence: // No operands
DWARF_LOG_TRACE(" DW_LNE_end_sequence");
_state->_end_sequence = true;
_state->_append_row = true;
_state->_do_reset = true;
break;
case DW_LNE_set_address: // 1 operand
if (!_reader.read_address_sized(&_state->_address)) {
return false;
}
DWARF_LOG_TRACE(" DW_LNE_set_address " INTPTR_FORMAT, _state->_address);
if (_state->_dwarf_version == 4) {
_state->_op_index = 0;
}
break;
case DW_LNE_define_file: // 4 operands
DWARF_LOG_TRACE(" DW_LNE_define_file");
if (!_reader.read_string()) {
return false;
}
// Operand 2-4: uleb128 numbers we do not care about.
if (!_reader.read_uleb128_ignore()
|| !_reader.read_uleb128_ignore()
|| !_reader.read_uleb128_ignore()) {
return false;
}
break;
case DW_LNE_set_discriminator: // 1 operand
DWARF_LOG_TRACE(" DW_LNE_set_discriminator");
uint64_t discriminator;
// For some reason, GCC emits this opcode even for earlier versions than DWARF 4 which introduced this opcode.
// We need to consume it.
if (!_reader.read_uleb128(&discriminator, 4)) {
// Must be an unsigned integer as specified in section 6.2.2 of the DWARF 4 spec for the discriminator register.
return false;
}
_state->_discriminator = discriminator;
break;
default:
assert(false, "Unknown extended opcode");
return false;
}
return true;
}
// Specified in section 6.2.5.2 of the DWARF 4 spec.
bool DwarfFile::LineNumberProgram::apply_standard_opcode(const uint8_t opcode) {
switch (opcode) {
case DW_LNS_copy: // No operands
DWARF_LOG_TRACE(" DW_LNS_copy");
_state->_append_row = true;
_state->_basic_block = false;
_state->_prologue_end = false;
_state->_epilogue_begin = false;
if (_state->_dwarf_version == 4) {
_state->_discriminator = 0;
}
break;
case DW_LNS_advance_pc: { // 1 operand
uint64_t operation_advance;
if (!_reader.read_uleb128(&operation_advance, 4)) {
// Must be at most 4 bytes because the index register is only 4 bytes wide.
return false;
}
_state->add_to_address_register(operation_advance, _header);
if (_state->_dwarf_version == 4) {
_state->set_index_register(operation_advance, _header);
}
DWARF_LOG_TRACE(" DW_LNS_advance_pc (" INTPTR_FORMAT ")", _state->_address);
break;
}
case DW_LNS_advance_line: // 1 operand
int64_t line;
if (!_reader.read_sleb128(&line, 4)) {
// line register is 4 bytes wide.
return false;
}
_state->_line += line;
DWARF_LOG_TRACE(" DW_LNS_advance_line (%d)", _state->_line);
break;
case DW_LNS_set_file: // 1 operand
uint64_t file;
if (!_reader.read_uleb128(&file, 4)) {
// file register is 4 bytes wide.
return false;
}
_state->_file = file;
DWARF_LOG_TRACE(" DW_LNS_set_file (%u)", _state->_file);
break;
case DW_LNS_set_column: // 1 operand
uint64_t column;
if (!_reader.read_uleb128(&column, 4)) {
// column register is 4 bytes wide.
return false;
}
_state->_column = column;
DWARF_LOG_TRACE(" DW_LNS_set_column (%u)", _state->_column);
break;
case DW_LNS_negate_stmt: // No operands
DWARF_LOG_TRACE(" DW_LNS_negate_stmt");
_state->_is_stmt = !_state->_is_stmt;
break;
case DW_LNS_set_basic_block: // No operands
DWARF_LOG_TRACE(" DW_LNS_set_basic_block");
_state->_basic_block = true;
break;
case DW_LNS_const_add_pc: { // No operands
// Update address and op_index registers by the increments of special opcode 255.
uint8_t adjusted_opcode_255 = 255 - _header._opcode_base;
uint8_t operation_advance = adjusted_opcode_255 / _header._line_range;
uintptr_t old_address = _state->_address;
_state->add_to_address_register(operation_advance, _header);
if (_state->_dwarf_version == 4) {
_state->set_index_register(operation_advance, _header);
}
DWARF_LOG_TRACE(" DW_LNS_const_add_pc (" INTPTR_FORMAT ")", _state->_address - old_address);
break;
}
case DW_LNS_fixed_advance_pc: // 1 operand
uint16_t operand;
if (!_reader.read_word(&operand)) {
return false;
}
_state->_address += operand;
_state->_op_index = 0;
DWARF_LOG_TRACE(" DW_LNS_fixed_advance_pc (" INTPTR_FORMAT ")", _state->_address);
break;
case DW_LNS_set_prologue_end: // No operands
DWARF_LOG_TRACE(" DW_LNS_set_basic_block");
_state->_prologue_end = true;
break;
case DW_LNS_set_epilogue_begin: // No operands
DWARF_LOG_TRACE(" DW_LNS_set_epilogue_begin");
_state->_epilogue_begin = true;
break;
case DW_LNS_set_isa: // 1 operand
uint64_t isa;
if (!_reader.read_uleb128(&isa, 4)) {
// isa register is 4 bytes wide.
return false;
}
_state->_isa = isa;
DWARF_LOG_TRACE(" DW_LNS_set_isa (%u)", _state->_isa);
break;
default:
assert(false, "Unknown standard opcode");
return false;
}
return true;
}
// Specified in section 6.2.5.1 of the DWARF 4 spec.
void DwarfFile::LineNumberProgram::apply_special_opcode(const uint8_t opcode) {
uintptr_t old_address = _state->_address;
uint32_t old_line = _state->_line;
uint8_t adjusted_opcode = opcode - _header._opcode_base;
uint8_t operation_advance = adjusted_opcode / _header._line_range;
_state->add_to_address_register(operation_advance, _header);
if (_state->_dwarf_version == 4) {
_state->set_index_register(operation_advance, _header);
_state->_discriminator = 0;
}
_state->_line += _header._line_base + (adjusted_opcode % _header._line_range);
DWARF_LOG_TRACE(" address += " INTPTR_FORMAT ", line += %d", _state->_address - old_address,
_state->_line - old_line);
_state->_append_row = true;
_state->_basic_block = false;
_state->_prologue_end = false;
_state->_epilogue_begin = false;
}
bool DwarfFile::LineNumberProgram::does_offset_match_entry(const uintptr_t previous_address, const uint32_t previous_file,
const uint32_t previous_line) {
if (_state->_can_sequence_match_offset) {
bool matches_entry_directly = _offset_in_library == _state->_address;
if (matches_entry_directly
|| (_offset_in_library > previous_address && _offset_in_library < _state->_address)) { // in between two entries
_state->_found_match = true;
if (!matches_entry_directly || _is_pc_after_call) {
// We take the previous row in the matrix either when:
// - We try to match an offset that is between two entries.
// - We have an offset from a PC that is at a call-site in which case we need to get the line information for
// the call instruction in the previous entry.
print_and_store_prev_entry(previous_file, previous_line);
return true;
} else if (!_reader.has_bytes_left()) {
// We take the current entry when this is the very last entry in the matrix (i.e. must be the right one).
DWARF_LOG_DEBUG("^^^ Found line for requested offset " UINT32_FORMAT_X_0 " ^^^", _offset_in_library);
return true;
}
// Else: Exact match. We cannot take this entry because we do not know if there are more entries following this
// one with the same offset (we could have multiple entries for the same address in the matrix). Continue
// to parse entries. When we have the first non-exact match, then we know that the previous entry is the
// correct one to take (handled in the else-if-case below). If this is the very last entry in a matrix,
// we will take the current entry (handled in else-if-case above).
} else if (_state->_found_match) {
// We found an entry before with an exact match. This is now the first entry with a new offset. Pick the previous
// entry which matches our offset and is guaranteed to be the last entry which matches our offset (if there are
// multiple entries with the same offset).
print_and_store_prev_entry(previous_file, previous_line);
return true;
}
}
return false;
}
void DwarfFile::LineNumberProgram::print_and_store_prev_entry(const uint32_t previous_file, const uint32_t previous_line) {
_state->_file = previous_file;
_state->_line = previous_line;
DWARF_LOG_DEBUG("^^^ Found line for requested offset " UINT32_FORMAT_X_0 " ^^^", _offset_in_library);
// Also print the currently parsed entry.
DWARF_LOG_DEBUG(INTPTR_FORMAT " %-5u %-3u %-4u",
_state->_address, _state->_line, _state->_column, _state->_file);
}
// Read field file_names from the header as specified in section 6.2.4 of the DWARF 4 spec.
bool DwarfFile::LineNumberProgram::get_filename_from_header(const uint32_t file_index, char* filename, const size_t filename_len) {
// We do not need to restore the position afterwards as this is the last step of parsing from the file for this compilation unit.
_reader.set_position(_header._file_names_offset);
uint32_t current_index = 1; // file_names start at index 1
while (_reader.has_bytes_left()) {
if (current_index == file_index) {
// Found correct file.
return read_filename(filename, filename_len);
} else if (!_reader.read_string()) { // We don't care about this filename string. Read and ignore it.
// Either an error while reading or we have reached the end of the file_names section before reaching the file_index.
// Both should not happen.
return false;
}
// We don't care about these values.
if (!_reader.read_uleb128_ignore() // Read directory index
|| !_reader.read_uleb128_ignore() // Read last modification of file
|| !_reader.read_uleb128_ignore()) { // Read file length
return false;
}
current_index++;
}
DWARF_LOG_DEBUG("Did not find filename entry at index " UINT32_FORMAT " in .debug_line header", file_index);
return false;
}
// Read the filename into the provided 'filename' buffer. If it does not fit, an alternative smaller tag will be emitted
// in order to let the DWARF parser succeed. The line number with a function name will almost always be sufficient to get
// to the actual source code location.
bool DwarfFile::LineNumberProgram::read_filename(char* filename, const size_t filename_len) {
char next_char;
if (!_reader.read_non_null_char(&next_char)) {
// Either error while reading or read an empty string which indicates the end of the file_names section.
// Both should not happen.
return false;
}
filename[0] = next_char;
size_t index = 1;
bool overflow_filename = false; // Is the currently read filename overflowing the provided 'filename' buffer?
while (next_char != '\0' && _reader.has_bytes_left()) {
if (!_reader.read_byte(&next_char)) {
return false;
}
if (next_char == *os::file_separator()) {
// Skip file separator to get to the actual filename and reset the buffer and overflow flag. GCC does not emit
// file separators while Clang does.
index = 0;
overflow_filename = false;
} else if (index == filename_len) {
// Just keep reading as we could read another file separator and reset the buffer again. But don't bother to store
// the additionally read characters as it would not fit into the buffer anyway.
overflow_filename = true;
} else {
assert(!overflow_filename, "sanity check");
filename[index] = next_char;
index++;
}
}
if (overflow_filename) {
// 'filename' buffer overflow. Store either a generic overflow message or a minimal filename.
write_filename_for_overflow(filename, filename_len);
}
return true;
}
// Try to write a generic overflow message to the provided buffer. If it does not fit, store the minimal filename "L"
// which always fits to get the source information in the form "L:line_number".
void DwarfFile::LineNumberProgram::write_filename_for_overflow(char* filename, const size_t filename_len) {
DWARF_LOG_ERROR("DWARF filename string is too large to fit into the provided buffer of size %zu.", filename_len);
const size_t filename_overflow_message_length = strlen(overflow_filename) + 1;
if (filename_overflow_message_length <= filename_len) {
jio_snprintf(filename, filename_overflow_message_length, "%s", overflow_filename);
DWARF_LOG_ERROR("Use overflow filename: %s", overflow_filename);
} else {
// Buffer too small of generic overflow message.
DWARF_LOG_ERROR("Too small for overflow filename, use minimal filename: %c", minimal_overflow_filename);
assert(filename_len > 1, "sanity check");
filename[0] = minimal_overflow_filename;
filename[1] = '\0';
}
}
void DwarfFile::LineNumberProgram::LineNumberProgramState::reset_fields() {
_address = 0;
_op_index = 0;
_file = 1;
_line = 1;
_column = 0;
_is_stmt = _initial_is_stmt;
_basic_block = false;
_end_sequence = false;
_prologue_end = false;
_epilogue_begin = false;
_isa = 0;
_discriminator = 0;
_append_row = false;
_do_reset = false;
_first_entry_in_sequence = true;
_can_sequence_match_offset = false;
}
// Defined in section 6.2.5.1 of the DWARF 4 spec.
void DwarfFile::LineNumberProgram::LineNumberProgramState::add_to_address_register(const uint32_t operation_advance,
const LineNumberProgramHeader& header) {
if (_dwarf_version == 2 || _dwarf_version == 3) {
_address += (uintptr_t)(operation_advance * header._minimum_instruction_length);
} else if (_dwarf_version == 4) {
_address += (uintptr_t)(header._minimum_instruction_length *
((_op_index + operation_advance) / header._maximum_operations_per_instruction));
}
}
// Defined in section 6.2.5.1 of the DWARF 4 spec.
void DwarfFile::LineNumberProgram::LineNumberProgramState::set_index_register(const uint32_t operation_advance,
const LineNumberProgramHeader& header) {
_op_index = (_op_index + operation_advance) % header._maximum_operations_per_instruction;
}
bool DwarfFile::MarkedDwarfFileReader::set_position(const long new_pos) {
if (new_pos < 0) {
return false;
}
_current_pos = new_pos;
return FileReader::set_position(new_pos);
}
bool DwarfFile::MarkedDwarfFileReader::has_bytes_left() const {
if (_max_pos == -1) {
return false;
}
return _current_pos < _max_pos;
}
bool DwarfFile::MarkedDwarfFileReader::update_to_stored_position() {
_marked_pos = ftell(_fd);
if (_marked_pos < 0) {
return false;
}
return FileReader::set_position(_current_pos);
}
bool DwarfFile::MarkedDwarfFileReader::reset_to_previous_position() {
return FileReader::set_position(_marked_pos);
}
bool DwarfFile::MarkedDwarfFileReader::move_position(const long offset) {
if (offset == 0) {
return true;
}
return set_position(_current_pos + offset);
}
bool DwarfFile::MarkedDwarfFileReader::read_byte(void* result) {
_current_pos++;
return read(result, 1);
}
bool DwarfFile::MarkedDwarfFileReader::read_word(uint16_t* result) {
_current_pos += 2;
return read(result, 2);
}
bool DwarfFile::MarkedDwarfFileReader::read_dword(uint32_t* result) {
_current_pos += 4;
return read(result, 4);
}
bool DwarfFile::MarkedDwarfFileReader::read_qword(uint64_t* result) {
_current_pos += 8;
return read(result, 8);
}
bool DwarfFile::MarkedDwarfFileReader::read_address_sized(uintptr_t* result) {
_current_pos += DwarfFile::ADDRESS_SIZE;
return read(result, DwarfFile::ADDRESS_SIZE);
}
// See Figure 46/47 in Appendix C of the DWARF 4 spec.
bool DwarfFile::MarkedDwarfFileReader::read_leb128(uint64_t* result, const int8_t check_size, bool is_signed) {
*result = 0; // Ensure a proper result by zeroing it first.
uint8_t buf;
uint8_t shift = 0;
uint8_t bytes_read = 0;
// leb128 is not larger than 8 bytes.
while (bytes_read < 8) {
if (!read_byte(&buf)) {
return false;
}
bytes_read++;
*result |= (buf & 0x7fu) << shift;
shift += 7;
if ((buf & 0x80u) == 0) {
break;
}
}
if (bytes_read > 8 || (check_size != -1 && bytes_read > check_size)) {
// Invalid leb128 encoding or the read leb128 was larger than expected.
return false;
}
if (is_signed && (shift < 64) && (buf & 0x40u)) {
*result |= static_cast<uint64_t>(-1L) << shift;
}
return true;
}
bool DwarfFile::MarkedDwarfFileReader::read_uleb128_ignore(const int8_t check_size) {
uint64_t dont_care;
return read_leb128(&dont_care, check_size, false);
}
bool DwarfFile::MarkedDwarfFileReader::read_uleb128(uint64_t* result, const int8_t check_size) {
return read_leb128(result, check_size, false);
}
bool DwarfFile::MarkedDwarfFileReader::read_sleb128(int64_t* result, const int8_t check_size) {
return read_leb128((uint64_t*)result, check_size, true);
}
// If result is a null, we do not care about the content of the string being read.
bool DwarfFile::MarkedDwarfFileReader::read_string(char* result, const size_t result_len) {
char first_char;
if (!read_non_null_char(&first_char)) {
return false;
}
if (result != nullptr) {
if (result_len < 2) {
// Strings must contain at least one non-null byte and a null byte terminator.
return false;
}
result[0] = first_char;
}
uint8_t next_byte;
size_t char_index = 1;
bool exceeded_buffer = false;
while (has_bytes_left()) {
// Read until we find a null byte which terminates the string.
if (!read_byte(&next_byte)) {
return false;
}
if (result != nullptr) {
if (char_index >= result_len) {
// Exceeded buffer size of 'result'.
exceeded_buffer = true;
} else {
result[char_index] = (char)next_byte;
}
char_index++;
}
if (next_byte == 0) {
if (exceeded_buffer) {
result[result_len - 1] = '\0'; // Mark end of string.
DWARF_LOG_ERROR("Tried to read " SIZE_FORMAT " bytes but exceeded buffer size of " SIZE_FORMAT ". Truncating string.",
char_index, result_len);
}
return true;
}
}
return false;
}
bool DwarfFile::MarkedDwarfFileReader::read_non_null_char(char* result) {
if (!read_byte(result)) {
return false;
}
return *result != '\0';
}
#endif // !_WINDOWS && !__APPLE__