PK �zFZ��ǻ] ] debuginfod.hnu �[��� /* External declarations for the libdebuginfod client library.
Copyright (C) 2019-2020 Red Hat, Inc.
This file is part of elfutils.
This file is free software; you can redistribute it and/or modify
it under the terms of either
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at
your option) any later version
or
* the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at
your option) any later version
or both in parallel, as here.
elfutils 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 for more details.
You should have received copies of the GNU General Public License and
the GNU Lesser General Public License along with this program. If
not, see <http://www.gnu.org/licenses/>. */
#ifndef _DEBUGINFOD_CLIENT_H
#define _DEBUGINFOD_CLIENT_H 1
/* Names of environment variables that control the client logic. */
#define DEBUGINFOD_URLS_ENV_VAR "DEBUGINFOD_URLS"
#define DEBUGINFOD_CACHE_PATH_ENV_VAR "DEBUGINFOD_CACHE_PATH"
#define DEBUGINFOD_TIMEOUT_ENV_VAR "DEBUGINFOD_TIMEOUT"
#define DEBUGINFOD_PROGRESS_ENV_VAR "DEBUGINFOD_PROGRESS"
#define DEBUGINFOD_VERBOSE_ENV_VAR "DEBUGINFOD_VERBOSE"
#define DEBUGINFOD_RETRY_LIMIT_ENV_VAR "DEBUGINFOD_RETRY_LIMIT"
#define DEBUGINFOD_MAXSIZE_ENV_VAR "DEBUGINFOD_MAXSIZE"
#define DEBUGINFOD_MAXTIME_ENV_VAR "DEBUGINFOD_MAXTIME"
#define DEBUGINFOD_HEADERS_FILE_ENV_VAR "DEBUGINFOD_HEADERS_FILE"
/* The libdebuginfod soname. */
#define DEBUGINFOD_SONAME "libdebuginfod.so.1"
/* Handle for debuginfod-client connection. */
#ifndef _ELFUTILS_DEBUGINFOD_CLIENT_TYPEDEF
typedef struct debuginfod_client debuginfod_client;
#define _ELFUTILS_DEBUGINFOD_CLIENT_TYPEDEF 1
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Create a handle for a new debuginfod-client session. */
debuginfod_client *debuginfod_begin (void);
/* Query the urls contained in $DEBUGINFOD_URLS for a file with
the specified type and build id. If build_id_len == 0, the
build_id is supplied as a lowercase hexadecimal string; otherwise
it is a binary blob of given length.
If successful, return a file descriptor to the target, otherwise
return a posix error code. If successful, set *path to a
strdup'd copy of the name of the same file in the cache.
Caller must free() it later. */
int debuginfod_find_debuginfo (debuginfod_client *client,
const unsigned char *build_id,
int build_id_len,
char **path);
int debuginfod_find_executable (debuginfod_client *client,
const unsigned char *build_id,
int build_id_len,
char **path);
int debuginfod_find_source (debuginfod_client *client,
const unsigned char *build_id,
int build_id_len,
const char *filename,
char **path);
int debuginfod_find_section (debuginfod_client *client,
const unsigned char *build_id,
int build_id_len,
const char *section,
char **path);
typedef int (*debuginfod_progressfn_t)(debuginfod_client *c, long a, long b);
void debuginfod_set_progressfn(debuginfod_client *c,
debuginfod_progressfn_t fn);
void debuginfod_set_verbose_fd(debuginfod_client *c, int fd);
/* Set the user parameter. */
void debuginfod_set_user_data (debuginfod_client *client, void *value);
/* Get the user parameter. */
void* debuginfod_get_user_data (debuginfod_client *client);
/* Get the current or last active URL, if known. */
const char* debuginfod_get_url (debuginfod_client *client);
/* Returns set of x-debuginfod* header lines received from current or
last active transfer, \n separated, if known. */
const char* debuginfod_get_headers(debuginfod_client *client);
/* Add an outgoing HTTP request "Header: Value". Copies string. */
int debuginfod_add_http_header (debuginfod_client *client, const char* header);
/* Release debuginfod client connection context handle. */
void debuginfod_end (debuginfod_client *client);
#ifdef __cplusplus
}
#endif
#endif /* _DEBUGINFOD_CLIENT_H */
PK �zFZ��x�W W elf-knowledge.hnu �[��� /* Accumulation of various pieces of knowledge about ELF.
Copyright (C) 2000-2012, 2014, 2016 Red Hat, Inc.
This file is part of elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2000.
This file is free software; you can redistribute it and/or modify
it under the terms of either
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at
your option) any later version
or
* the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at
your option) any later version
or both in parallel, as here.
elfutils 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 for more details.
You should have received copies of the GNU General Public License and
the GNU Lesser General Public License along with this program. If
not, see <http://www.gnu.org/licenses/>. */
#ifndef _ELF_KNOWLEDGE_H
#define _ELF_KNOWLEDGE_H 1
#include <stdbool.h>
/* Test whether a section can be stripped or not. */
#define SECTION_STRIP_P(shdr, name, remove_comment) \
/* Sections which are allocated are not removed. */ \
(((shdr)->sh_flags & SHF_ALLOC) == 0 \
/* We never remove .note sections. */ \
&& (shdr)->sh_type != SHT_NOTE \
&& (((shdr)->sh_type) != SHT_PROGBITS \
/* Never remove .gnu.warning.* sections. */ \
|| (name != NULL \
&& strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) != 0\
/* We remove .comment sections only if explicitly told to do so. */\
&& (remove_comment \
|| strcmp (name, ".comment") != 0))))
/* Test whether `sh_info' field in section header contains a section
index. There are two kinds of sections doing this:
- the sections containing relocation information reference in this
field the section to which the relocations apply;
- section with the SHF_INFO_LINK flag set to signal that `sh_info'
references a section. This allows correct handling of unknown
sections. */
#define SH_INFO_LINK_P(Shdr) \
((Shdr)->sh_type == SHT_REL || (Shdr)->sh_type == SHT_RELA \
|| ((Shdr)->sh_flags & SHF_INFO_LINK) != 0)
/* Size of an entry in the hash table. The ELF specification says all
entries are regardless of platform 32-bits in size. Early 64-bit
ports (namely Alpha for Linux) got this wrong. The wording was not
clear.
Several years later the ABI for the 64-bit S390s was developed.
Many things were copied from the IA-64 ABI (which uses the correct
32-bit entry size) but it does get the SHT_HASH entry size wrong by
using a 64-bit entry size. So now we need this macro to special
case both the alpha and s390x ABIs. */
#define SH_ENTSIZE_HASH(Ehdr) \
((Ehdr)->e_machine == EM_ALPHA \
|| ((Ehdr)->e_machine == EM_S390 \
&& (Ehdr)->e_ident[EI_CLASS] == ELFCLASS64) ? 8 : 4)
/* GNU Annobin notes are not fully standardized and abuses the owner name. */
#define ELF_NOTE_GNU_BUILD_ATTRIBUTE_PREFIX "GA"
#define NT_GNU_BUILD_ATTRIBUTE_OPEN 0x100
#define NT_GNU_BUILD_ATTRIBUTE_FUNC 0x101
#define GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC '*'
#define GNU_BUILD_ATTRIBUTE_TYPE_STRING '$'
#define GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE '+'
#define GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE '!'
#define GNU_BUILD_ATTRIBUTE_VERSION 1
#define GNU_BUILD_ATTRIBUTE_STACK_PROT 2
#define GNU_BUILD_ATTRIBUTE_RELRO 3
#define GNU_BUILD_ATTRIBUTE_STACK_SIZE 4
#define GNU_BUILD_ATTRIBUTE_TOOL 5
#define GNU_BUILD_ATTRIBUTE_ABI 6
#define GNU_BUILD_ATTRIBUTE_PIC 7
#define GNU_BUILD_ATTRIBUTE_SHORT_ENUM 8
#endif /* elf-knowledge.h */
PK �zFZ\~\�k� k�
known-dwarf.hnu �[��� /* Generated by config/known-dwarf.awk from libdw/dwarf.h contents. */
#define DWARF_ALL_KNOWN_DW_ACCESS \
DWARF_ONE_KNOWN_DW_ACCESS (private, DW_ACCESS_private) \
DWARF_ONE_KNOWN_DW_ACCESS (protected, DW_ACCESS_protected) \
DWARF_ONE_KNOWN_DW_ACCESS (public, DW_ACCESS_public) \
/* End of DW_ACCESS_*. */
#define DWARF_ALL_KNOWN_DW_AT \
DWARF_ONE_KNOWN_DW_AT (GNU_addr_base, DW_AT_GNU_addr_base) \
DWARF_ONE_KNOWN_DW_AT (GNU_all_call_sites, DW_AT_GNU_all_call_sites) \
DWARF_ONE_KNOWN_DW_AT (GNU_all_source_call_sites, DW_AT_GNU_all_source_call_sites) \
DWARF_ONE_KNOWN_DW_AT (GNU_all_tail_call_sites, DW_AT_GNU_all_tail_call_sites) \
DWARF_ONE_KNOWN_DW_AT (GNU_bias, DW_AT_GNU_bias) \
DWARF_ONE_KNOWN_DW_AT (GNU_call_site_data_value, DW_AT_GNU_call_site_data_value) \
DWARF_ONE_KNOWN_DW_AT (GNU_call_site_target, DW_AT_GNU_call_site_target) \
DWARF_ONE_KNOWN_DW_AT (GNU_call_site_target_clobbered, DW_AT_GNU_call_site_target_clobbered) \
DWARF_ONE_KNOWN_DW_AT (GNU_call_site_value, DW_AT_GNU_call_site_value) \
DWARF_ONE_KNOWN_DW_AT (GNU_deleted, DW_AT_GNU_deleted) \
DWARF_ONE_KNOWN_DW_AT (GNU_denominator, DW_AT_GNU_denominator) \
DWARF_ONE_KNOWN_DW_AT (GNU_dwo_id, DW_AT_GNU_dwo_id) \
DWARF_ONE_KNOWN_DW_AT (GNU_dwo_name, DW_AT_GNU_dwo_name) \
DWARF_ONE_KNOWN_DW_AT (GNU_entry_view, DW_AT_GNU_entry_view) \
DWARF_ONE_KNOWN_DW_AT (GNU_exclusive_locks_required, DW_AT_GNU_exclusive_locks_required) \
DWARF_ONE_KNOWN_DW_AT (GNU_guarded, DW_AT_GNU_guarded) \
DWARF_ONE_KNOWN_DW_AT (GNU_guarded_by, DW_AT_GNU_guarded_by) \
DWARF_ONE_KNOWN_DW_AT (GNU_locks_excluded, DW_AT_GNU_locks_excluded) \
DWARF_ONE_KNOWN_DW_AT (GNU_locviews, DW_AT_GNU_locviews) \
DWARF_ONE_KNOWN_DW_AT (GNU_macros, DW_AT_GNU_macros) \
DWARF_ONE_KNOWN_DW_AT (GNU_numerator, DW_AT_GNU_numerator) \
DWARF_ONE_KNOWN_DW_AT (GNU_odr_signature, DW_AT_GNU_odr_signature) \
DWARF_ONE_KNOWN_DW_AT (GNU_pt_guarded, DW_AT_GNU_pt_guarded) \
DWARF_ONE_KNOWN_DW_AT (GNU_pt_guarded_by, DW_AT_GNU_pt_guarded_by) \
DWARF_ONE_KNOWN_DW_AT (GNU_pubnames, DW_AT_GNU_pubnames) \
DWARF_ONE_KNOWN_DW_AT (GNU_pubtypes, DW_AT_GNU_pubtypes) \
DWARF_ONE_KNOWN_DW_AT (GNU_ranges_base, DW_AT_GNU_ranges_base) \
DWARF_ONE_KNOWN_DW_AT (GNU_shared_locks_required, DW_AT_GNU_shared_locks_required) \
DWARF_ONE_KNOWN_DW_AT (GNU_tail_call, DW_AT_GNU_tail_call) \
DWARF_ONE_KNOWN_DW_AT (GNU_template_name, DW_AT_GNU_template_name) \
DWARF_ONE_KNOWN_DW_AT (GNU_vector, DW_AT_GNU_vector) \
DWARF_ONE_KNOWN_DW_AT (MIPS_abstract_name, DW_AT_MIPS_abstract_name) \
DWARF_ONE_KNOWN_DW_AT (MIPS_allocatable_dopetype, DW_AT_MIPS_allocatable_dopetype) \
DWARF_ONE_KNOWN_DW_AT (MIPS_assumed_shape_dopetype, DW_AT_MIPS_assumed_shape_dopetype) \
DWARF_ONE_KNOWN_DW_AT (MIPS_assumed_size, DW_AT_MIPS_assumed_size) \
DWARF_ONE_KNOWN_DW_AT (MIPS_clone_origin, DW_AT_MIPS_clone_origin) \
DWARF_ONE_KNOWN_DW_AT (MIPS_epilog_begin, DW_AT_MIPS_epilog_begin) \
DWARF_ONE_KNOWN_DW_AT (MIPS_fde, DW_AT_MIPS_fde) \
DWARF_ONE_KNOWN_DW_AT (MIPS_has_inlines, DW_AT_MIPS_has_inlines) \
DWARF_ONE_KNOWN_DW_AT (MIPS_linkage_name, DW_AT_MIPS_linkage_name) \
DWARF_ONE_KNOWN_DW_AT (MIPS_loop_begin, DW_AT_MIPS_loop_begin) \
DWARF_ONE_KNOWN_DW_AT (MIPS_loop_unroll_factor, DW_AT_MIPS_loop_unroll_factor) \
DWARF_ONE_KNOWN_DW_AT (MIPS_ptr_dopetype, DW_AT_MIPS_ptr_dopetype) \
DWARF_ONE_KNOWN_DW_AT (MIPS_software_pipeline_depth, DW_AT_MIPS_software_pipeline_depth) \
DWARF_ONE_KNOWN_DW_AT (MIPS_stride, DW_AT_MIPS_stride) \
DWARF_ONE_KNOWN_DW_AT (MIPS_stride_byte, DW_AT_MIPS_stride_byte) \
DWARF_ONE_KNOWN_DW_AT (MIPS_stride_elem, DW_AT_MIPS_stride_elem) \
DWARF_ONE_KNOWN_DW_AT (MIPS_tail_loop_begin, DW_AT_MIPS_tail_loop_begin) \
DWARF_ONE_KNOWN_DW_AT (abstract_origin, DW_AT_abstract_origin) \
DWARF_ONE_KNOWN_DW_AT (accessibility, DW_AT_accessibility) \
DWARF_ONE_KNOWN_DW_AT (addr_base, DW_AT_addr_base) \
DWARF_ONE_KNOWN_DW_AT (address_class, DW_AT_address_class) \
DWARF_ONE_KNOWN_DW_AT (alignment, DW_AT_alignment) \
DWARF_ONE_KNOWN_DW_AT (allocated, DW_AT_allocated) \
DWARF_ONE_KNOWN_DW_AT (artificial, DW_AT_artificial) \
DWARF_ONE_KNOWN_DW_AT (associated, DW_AT_associated) \
DWARF_ONE_KNOWN_DW_AT (base_types, DW_AT_base_types) \
DWARF_ONE_KNOWN_DW_AT (binary_scale, DW_AT_binary_scale) \
DWARF_ONE_KNOWN_DW_AT (bit_offset, DW_AT_bit_offset) \
DWARF_ONE_KNOWN_DW_AT (bit_size, DW_AT_bit_size) \
DWARF_ONE_KNOWN_DW_AT (bit_stride, DW_AT_bit_stride) \
DWARF_ONE_KNOWN_DW_AT (body_begin, DW_AT_body_begin) \
DWARF_ONE_KNOWN_DW_AT (body_end, DW_AT_body_end) \
DWARF_ONE_KNOWN_DW_AT (byte_size, DW_AT_byte_size) \
DWARF_ONE_KNOWN_DW_AT (byte_stride, DW_AT_byte_stride) \
DWARF_ONE_KNOWN_DW_AT (call_all_calls, DW_AT_call_all_calls) \
DWARF_ONE_KNOWN_DW_AT (call_all_source_calls, DW_AT_call_all_source_calls) \
DWARF_ONE_KNOWN_DW_AT (call_all_tail_calls, DW_AT_call_all_tail_calls) \
DWARF_ONE_KNOWN_DW_AT (call_column, DW_AT_call_column) \
DWARF_ONE_KNOWN_DW_AT (call_data_location, DW_AT_call_data_location) \
DWARF_ONE_KNOWN_DW_AT (call_data_value, DW_AT_call_data_value) \
DWARF_ONE_KNOWN_DW_AT (call_file, DW_AT_call_file) \
DWARF_ONE_KNOWN_DW_AT (call_line, DW_AT_call_line) \
DWARF_ONE_KNOWN_DW_AT (call_origin, DW_AT_call_origin) \
DWARF_ONE_KNOWN_DW_AT (call_parameter, DW_AT_call_parameter) \
DWARF_ONE_KNOWN_DW_AT (call_pc, DW_AT_call_pc) \
DWARF_ONE_KNOWN_DW_AT (call_return_pc, DW_AT_call_return_pc) \
DWARF_ONE_KNOWN_DW_AT (call_tail_call, DW_AT_call_tail_call) \
DWARF_ONE_KNOWN_DW_AT (call_target, DW_AT_call_target) \
DWARF_ONE_KNOWN_DW_AT (call_target_clobbered, DW_AT_call_target_clobbered) \
DWARF_ONE_KNOWN_DW_AT (call_value, DW_AT_call_value) \
DWARF_ONE_KNOWN_DW_AT (calling_convention, DW_AT_calling_convention) \
DWARF_ONE_KNOWN_DW_AT (common_reference, DW_AT_common_reference) \
DWARF_ONE_KNOWN_DW_AT (comp_dir, DW_AT_comp_dir) \
DWARF_ONE_KNOWN_DW_AT (const_expr, DW_AT_const_expr) \
DWARF_ONE_KNOWN_DW_AT (const_value, DW_AT_const_value) \
DWARF_ONE_KNOWN_DW_AT (containing_type, DW_AT_containing_type) \
DWARF_ONE_KNOWN_DW_AT (count, DW_AT_count) \
DWARF_ONE_KNOWN_DW_AT (data_bit_offset, DW_AT_data_bit_offset) \
DWARF_ONE_KNOWN_DW_AT (data_location, DW_AT_data_location) \
DWARF_ONE_KNOWN_DW_AT (data_member_location, DW_AT_data_member_location) \
DWARF_ONE_KNOWN_DW_AT (decimal_scale, DW_AT_decimal_scale) \
DWARF_ONE_KNOWN_DW_AT (decimal_sign, DW_AT_decimal_sign) \
DWARF_ONE_KNOWN_DW_AT (decl_column, DW_AT_decl_column) \
DWARF_ONE_KNOWN_DW_AT (decl_file, DW_AT_decl_file) \
DWARF_ONE_KNOWN_DW_AT (decl_line, DW_AT_decl_line) \
DWARF_ONE_KNOWN_DW_AT (declaration, DW_AT_declaration) \
DWARF_ONE_KNOWN_DW_AT (default_value, DW_AT_default_value) \
DWARF_ONE_KNOWN_DW_AT (defaulted, DW_AT_defaulted) \
DWARF_ONE_KNOWN_DW_AT (deleted, DW_AT_deleted) \
DWARF_ONE_KNOWN_DW_AT (description, DW_AT_description) \
DWARF_ONE_KNOWN_DW_AT (digit_count, DW_AT_digit_count) \
DWARF_ONE_KNOWN_DW_AT (discr, DW_AT_discr) \
DWARF_ONE_KNOWN_DW_AT (discr_list, DW_AT_discr_list) \
DWARF_ONE_KNOWN_DW_AT (discr_value, DW_AT_discr_value) \
DWARF_ONE_KNOWN_DW_AT (dwo_name, DW_AT_dwo_name) \
DWARF_ONE_KNOWN_DW_AT (elemental, DW_AT_elemental) \
DWARF_ONE_KNOWN_DW_AT (encoding, DW_AT_encoding) \
DWARF_ONE_KNOWN_DW_AT (endianity, DW_AT_endianity) \
DWARF_ONE_KNOWN_DW_AT (entry_pc, DW_AT_entry_pc) \
DWARF_ONE_KNOWN_DW_AT (enum_class, DW_AT_enum_class) \
DWARF_ONE_KNOWN_DW_AT (explicit, DW_AT_explicit) \
DWARF_ONE_KNOWN_DW_AT (export_symbols, DW_AT_export_symbols) \
DWARF_ONE_KNOWN_DW_AT (extension, DW_AT_extension) \
DWARF_ONE_KNOWN_DW_AT (external, DW_AT_external) \
DWARF_ONE_KNOWN_DW_AT (frame_base, DW_AT_frame_base) \
DWARF_ONE_KNOWN_DW_AT (friend, DW_AT_friend) \
DWARF_ONE_KNOWN_DW_AT (high_pc, DW_AT_high_pc) \
DWARF_ONE_KNOWN_DW_AT (identifier_case, DW_AT_identifier_case) \
DWARF_ONE_KNOWN_DW_AT (import, DW_AT_import) \
DWARF_ONE_KNOWN_DW_AT (inline, DW_AT_inline) \
DWARF_ONE_KNOWN_DW_AT (is_optional, DW_AT_is_optional) \
DWARF_ONE_KNOWN_DW_AT (language, DW_AT_language) \
DWARF_ONE_KNOWN_DW_AT (linkage_name, DW_AT_linkage_name) \
DWARF_ONE_KNOWN_DW_AT (location, DW_AT_location) \
DWARF_ONE_KNOWN_DW_AT (loclists_base, DW_AT_loclists_base) \
DWARF_ONE_KNOWN_DW_AT (low_pc, DW_AT_low_pc) \
DWARF_ONE_KNOWN_DW_AT (lower_bound, DW_AT_lower_bound) \
DWARF_ONE_KNOWN_DW_AT (mac_info, DW_AT_mac_info) \
DWARF_ONE_KNOWN_DW_AT (macro_info, DW_AT_macro_info) \
DWARF_ONE_KNOWN_DW_AT (macros, DW_AT_macros) \
DWARF_ONE_KNOWN_DW_AT (main_subprogram, DW_AT_main_subprogram) \
DWARF_ONE_KNOWN_DW_AT (mutable, DW_AT_mutable) \
DWARF_ONE_KNOWN_DW_AT (name, DW_AT_name) \
DWARF_ONE_KNOWN_DW_AT (namelist_item, DW_AT_namelist_item) \
DWARF_ONE_KNOWN_DW_AT (noreturn, DW_AT_noreturn) \
DWARF_ONE_KNOWN_DW_AT (object_pointer, DW_AT_object_pointer) \
DWARF_ONE_KNOWN_DW_AT (ordering, DW_AT_ordering) \
DWARF_ONE_KNOWN_DW_AT (picture_string, DW_AT_picture_string) \
DWARF_ONE_KNOWN_DW_AT (priority, DW_AT_priority) \
DWARF_ONE_KNOWN_DW_AT (producer, DW_AT_producer) \
DWARF_ONE_KNOWN_DW_AT (prototyped, DW_AT_prototyped) \
DWARF_ONE_KNOWN_DW_AT (pure, DW_AT_pure) \
DWARF_ONE_KNOWN_DW_AT (ranges, DW_AT_ranges) \
DWARF_ONE_KNOWN_DW_AT (rank, DW_AT_rank) \
DWARF_ONE_KNOWN_DW_AT (recursive, DW_AT_recursive) \
DWARF_ONE_KNOWN_DW_AT (reference, DW_AT_reference) \
DWARF_ONE_KNOWN_DW_AT (return_addr, DW_AT_return_addr) \
DWARF_ONE_KNOWN_DW_AT (rnglists_base, DW_AT_rnglists_base) \
DWARF_ONE_KNOWN_DW_AT (rvalue_reference, DW_AT_rvalue_reference) \
DWARF_ONE_KNOWN_DW_AT (segment, DW_AT_segment) \
DWARF_ONE_KNOWN_DW_AT (sf_names, DW_AT_sf_names) \
DWARF_ONE_KNOWN_DW_AT (sibling, DW_AT_sibling) \
DWARF_ONE_KNOWN_DW_AT (signature, DW_AT_signature) \
DWARF_ONE_KNOWN_DW_AT (small, DW_AT_small) \
DWARF_ONE_KNOWN_DW_AT (specification, DW_AT_specification) \
DWARF_ONE_KNOWN_DW_AT (src_coords, DW_AT_src_coords) \
DWARF_ONE_KNOWN_DW_AT (src_info, DW_AT_src_info) \
DWARF_ONE_KNOWN_DW_AT (start_scope, DW_AT_start_scope) \
DWARF_ONE_KNOWN_DW_AT (static_link, DW_AT_static_link) \
DWARF_ONE_KNOWN_DW_AT (stmt_list, DW_AT_stmt_list) \
DWARF_ONE_KNOWN_DW_AT (str_offsets_base, DW_AT_str_offsets_base) \
DWARF_ONE_KNOWN_DW_AT (string_length, DW_AT_string_length) \
DWARF_ONE_KNOWN_DW_AT (string_length_bit_size, DW_AT_string_length_bit_size) \
DWARF_ONE_KNOWN_DW_AT (string_length_byte_size, DW_AT_string_length_byte_size) \
DWARF_ONE_KNOWN_DW_AT (threads_scaled, DW_AT_threads_scaled) \
DWARF_ONE_KNOWN_DW_AT (trampoline, DW_AT_trampoline) \
DWARF_ONE_KNOWN_DW_AT (type, DW_AT_type) \
DWARF_ONE_KNOWN_DW_AT (upper_bound, DW_AT_upper_bound) \
DWARF_ONE_KNOWN_DW_AT (use_UTF8, DW_AT_use_UTF8) \
DWARF_ONE_KNOWN_DW_AT (use_location, DW_AT_use_location) \
DWARF_ONE_KNOWN_DW_AT (variable_parameter, DW_AT_variable_parameter) \
DWARF_ONE_KNOWN_DW_AT (virtuality, DW_AT_virtuality) \
DWARF_ONE_KNOWN_DW_AT (visibility, DW_AT_visibility) \
DWARF_ONE_KNOWN_DW_AT (vtable_elem_location, DW_AT_vtable_elem_location) \
/* End of DW_AT_*. */
#define DWARF_ALL_KNOWN_DW_ATE \
DWARF_ONE_KNOWN_DW_ATE (ASCII, DW_ATE_ASCII) \
DWARF_ONE_KNOWN_DW_ATE (UCS, DW_ATE_UCS) \
DWARF_ONE_KNOWN_DW_ATE (UTF, DW_ATE_UTF) \
DWARF_ONE_KNOWN_DW_ATE (address, DW_ATE_address) \
DWARF_ONE_KNOWN_DW_ATE (boolean, DW_ATE_boolean) \
DWARF_ONE_KNOWN_DW_ATE (complex_float, DW_ATE_complex_float) \
DWARF_ONE_KNOWN_DW_ATE (decimal_float, DW_ATE_decimal_float) \
DWARF_ONE_KNOWN_DW_ATE (edited, DW_ATE_edited) \
DWARF_ONE_KNOWN_DW_ATE (float, DW_ATE_float) \
DWARF_ONE_KNOWN_DW_ATE (imaginary_float, DW_ATE_imaginary_float) \
DWARF_ONE_KNOWN_DW_ATE (numeric_string, DW_ATE_numeric_string) \
DWARF_ONE_KNOWN_DW_ATE (packed_decimal, DW_ATE_packed_decimal) \
DWARF_ONE_KNOWN_DW_ATE (signed, DW_ATE_signed) \
DWARF_ONE_KNOWN_DW_ATE (signed_char, DW_ATE_signed_char) \
DWARF_ONE_KNOWN_DW_ATE (signed_fixed, DW_ATE_signed_fixed) \
DWARF_ONE_KNOWN_DW_ATE (unsigned, DW_ATE_unsigned) \
DWARF_ONE_KNOWN_DW_ATE (unsigned_char, DW_ATE_unsigned_char) \
DWARF_ONE_KNOWN_DW_ATE (unsigned_fixed, DW_ATE_unsigned_fixed) \
DWARF_ONE_KNOWN_DW_ATE (void, DW_ATE_void) \
/* End of DW_ATE_*. */
#define DWARF_ALL_KNOWN_DW_CC \
DWARF_ONE_KNOWN_DW_CC (nocall, DW_CC_nocall) \
DWARF_ONE_KNOWN_DW_CC (normal, DW_CC_normal) \
DWARF_ONE_KNOWN_DW_CC (pass_by_reference, DW_CC_pass_by_reference) \
DWARF_ONE_KNOWN_DW_CC (pass_by_value, DW_CC_pass_by_value) \
DWARF_ONE_KNOWN_DW_CC (program, DW_CC_program) \
/* End of DW_CC_*. */
#define DWARF_ALL_KNOWN_DW_CFA \
DWARF_ONE_KNOWN_DW_CFA (AARCH64_negate_ra_state, DW_CFA_AARCH64_negate_ra_state) \
DWARF_ONE_KNOWN_DW_CFA (GNU_args_size, DW_CFA_GNU_args_size) \
DWARF_ONE_KNOWN_DW_CFA (GNU_negative_offset_extended, DW_CFA_GNU_negative_offset_extended) \
DWARF_ONE_KNOWN_DW_CFA (GNU_window_save, DW_CFA_GNU_window_save) \
DWARF_ONE_KNOWN_DW_CFA (MIPS_advance_loc8, DW_CFA_MIPS_advance_loc8) \
DWARF_ONE_KNOWN_DW_CFA (advance_loc, DW_CFA_advance_loc) \
DWARF_ONE_KNOWN_DW_CFA (advance_loc1, DW_CFA_advance_loc1) \
DWARF_ONE_KNOWN_DW_CFA (advance_loc2, DW_CFA_advance_loc2) \
DWARF_ONE_KNOWN_DW_CFA (advance_loc4, DW_CFA_advance_loc4) \
DWARF_ONE_KNOWN_DW_CFA (def_cfa, DW_CFA_def_cfa) \
DWARF_ONE_KNOWN_DW_CFA (def_cfa_expression, DW_CFA_def_cfa_expression) \
DWARF_ONE_KNOWN_DW_CFA (def_cfa_offset, DW_CFA_def_cfa_offset) \
DWARF_ONE_KNOWN_DW_CFA (def_cfa_offset_sf, DW_CFA_def_cfa_offset_sf) \
DWARF_ONE_KNOWN_DW_CFA (def_cfa_register, DW_CFA_def_cfa_register) \
DWARF_ONE_KNOWN_DW_CFA (def_cfa_sf, DW_CFA_def_cfa_sf) \
DWARF_ONE_KNOWN_DW_CFA (expression, DW_CFA_expression) \
DWARF_ONE_KNOWN_DW_CFA (extended, DW_CFA_extended) \
DWARF_ONE_KNOWN_DW_CFA (nop, DW_CFA_nop) \
DWARF_ONE_KNOWN_DW_CFA (offset, DW_CFA_offset) \
DWARF_ONE_KNOWN_DW_CFA (offset_extended, DW_CFA_offset_extended) \
DWARF_ONE_KNOWN_DW_CFA (offset_extended_sf, DW_CFA_offset_extended_sf) \
DWARF_ONE_KNOWN_DW_CFA (register, DW_CFA_register) \
DWARF_ONE_KNOWN_DW_CFA (remember_state, DW_CFA_remember_state) \
DWARF_ONE_KNOWN_DW_CFA (restore, DW_CFA_restore) \
DWARF_ONE_KNOWN_DW_CFA (restore_extended, DW_CFA_restore_extended) \
DWARF_ONE_KNOWN_DW_CFA (restore_state, DW_CFA_restore_state) \
DWARF_ONE_KNOWN_DW_CFA (same_value, DW_CFA_same_value) \
DWARF_ONE_KNOWN_DW_CFA (set_loc, DW_CFA_set_loc) \
DWARF_ONE_KNOWN_DW_CFA (undefined, DW_CFA_undefined) \
DWARF_ONE_KNOWN_DW_CFA (val_expression, DW_CFA_val_expression) \
DWARF_ONE_KNOWN_DW_CFA (val_offset, DW_CFA_val_offset) \
DWARF_ONE_KNOWN_DW_CFA (val_offset_sf, DW_CFA_val_offset_sf) \
/* End of DW_CFA_*. */
#define DWARF_ALL_KNOWN_DW_CHILDREN \
DWARF_ONE_KNOWN_DW_CHILDREN (no, DW_CHILDREN_no) \
DWARF_ONE_KNOWN_DW_CHILDREN (yes, DW_CHILDREN_yes) \
/* End of DW_CHILDREN_*. */
#define DWARF_ALL_KNOWN_DW_CIE_ID \
DWARF_ONE_KNOWN_DW_CIE_ID (32, DW_CIE_ID_32) \
DWARF_ONE_KNOWN_DW_CIE_ID (64, DW_CIE_ID_64) \
/* End of DW_CIE_ID_*. */
#define DWARF_ALL_KNOWN_DW_DEFAULTED \
DWARF_ONE_KNOWN_DW_DEFAULTED (in_class, DW_DEFAULTED_in_class) \
DWARF_ONE_KNOWN_DW_DEFAULTED (no, DW_DEFAULTED_no) \
DWARF_ONE_KNOWN_DW_DEFAULTED (out_of_class, DW_DEFAULTED_out_of_class) \
/* End of DW_DEFAULTED_*. */
#define DWARF_ALL_KNOWN_DW_DS \
DWARF_ONE_KNOWN_DW_DS (leading_overpunch, DW_DS_leading_overpunch) \
DWARF_ONE_KNOWN_DW_DS (leading_separate, DW_DS_leading_separate) \
DWARF_ONE_KNOWN_DW_DS (trailing_overpunch, DW_DS_trailing_overpunch) \
DWARF_ONE_KNOWN_DW_DS (trailing_separate, DW_DS_trailing_separate) \
DWARF_ONE_KNOWN_DW_DS (unsigned, DW_DS_unsigned) \
/* End of DW_DS_*. */
#define DWARF_ALL_KNOWN_DW_DSC \
DWARF_ONE_KNOWN_DW_DSC (label, DW_DSC_label) \
DWARF_ONE_KNOWN_DW_DSC (range, DW_DSC_range) \
/* End of DW_DSC_*. */
#define DWARF_ALL_KNOWN_DW_EH_PE \
DWARF_ONE_KNOWN_DW_EH_PE (absptr, DW_EH_PE_absptr) \
DWARF_ONE_KNOWN_DW_EH_PE (aligned, DW_EH_PE_aligned) \
DWARF_ONE_KNOWN_DW_EH_PE (datarel, DW_EH_PE_datarel) \
DWARF_ONE_KNOWN_DW_EH_PE (funcrel, DW_EH_PE_funcrel) \
DWARF_ONE_KNOWN_DW_EH_PE (indirect, DW_EH_PE_indirect) \
DWARF_ONE_KNOWN_DW_EH_PE (omit, DW_EH_PE_omit) \
DWARF_ONE_KNOWN_DW_EH_PE (pcrel, DW_EH_PE_pcrel) \
DWARF_ONE_KNOWN_DW_EH_PE (sdata2, DW_EH_PE_sdata2) \
DWARF_ONE_KNOWN_DW_EH_PE (sdata4, DW_EH_PE_sdata4) \
DWARF_ONE_KNOWN_DW_EH_PE (sdata8, DW_EH_PE_sdata8) \
DWARF_ONE_KNOWN_DW_EH_PE (signed, DW_EH_PE_signed) \
DWARF_ONE_KNOWN_DW_EH_PE (sleb128, DW_EH_PE_sleb128) \
DWARF_ONE_KNOWN_DW_EH_PE (textrel, DW_EH_PE_textrel) \
DWARF_ONE_KNOWN_DW_EH_PE (udata2, DW_EH_PE_udata2) \
DWARF_ONE_KNOWN_DW_EH_PE (udata4, DW_EH_PE_udata4) \
DWARF_ONE_KNOWN_DW_EH_PE (udata8, DW_EH_PE_udata8) \
DWARF_ONE_KNOWN_DW_EH_PE (uleb128, DW_EH_PE_uleb128) \
/* End of DW_EH_PE_*. */
#define DWARF_ALL_KNOWN_DW_END \
DWARF_ONE_KNOWN_DW_END (big, DW_END_big) \
DWARF_ONE_KNOWN_DW_END (default, DW_END_default) \
DWARF_ONE_KNOWN_DW_END (little, DW_END_little) \
/* End of DW_END_*. */
#define DWARF_ALL_KNOWN_DW_FORM \
DWARF_ONE_KNOWN_DW_FORM (GNU_addr_index, DW_FORM_GNU_addr_index) \
DWARF_ONE_KNOWN_DW_FORM (GNU_ref_alt, DW_FORM_GNU_ref_alt) \
DWARF_ONE_KNOWN_DW_FORM (GNU_str_index, DW_FORM_GNU_str_index) \
DWARF_ONE_KNOWN_DW_FORM (GNU_strp_alt, DW_FORM_GNU_strp_alt) \
DWARF_ONE_KNOWN_DW_FORM (addr, DW_FORM_addr) \
DWARF_ONE_KNOWN_DW_FORM (addrx, DW_FORM_addrx) \
DWARF_ONE_KNOWN_DW_FORM (addrx1, DW_FORM_addrx1) \
DWARF_ONE_KNOWN_DW_FORM (addrx2, DW_FORM_addrx2) \
DWARF_ONE_KNOWN_DW_FORM (addrx3, DW_FORM_addrx3) \
DWARF_ONE_KNOWN_DW_FORM (addrx4, DW_FORM_addrx4) \
DWARF_ONE_KNOWN_DW_FORM (block, DW_FORM_block) \
DWARF_ONE_KNOWN_DW_FORM (block1, DW_FORM_block1) \
DWARF_ONE_KNOWN_DW_FORM (block2, DW_FORM_block2) \
DWARF_ONE_KNOWN_DW_FORM (block4, DW_FORM_block4) \
DWARF_ONE_KNOWN_DW_FORM (data1, DW_FORM_data1) \
DWARF_ONE_KNOWN_DW_FORM (data16, DW_FORM_data16) \
DWARF_ONE_KNOWN_DW_FORM (data2, DW_FORM_data2) \
DWARF_ONE_KNOWN_DW_FORM (data4, DW_FORM_data4) \
DWARF_ONE_KNOWN_DW_FORM (data8, DW_FORM_data8) \
DWARF_ONE_KNOWN_DW_FORM (exprloc, DW_FORM_exprloc) \
DWARF_ONE_KNOWN_DW_FORM (flag, DW_FORM_flag) \
DWARF_ONE_KNOWN_DW_FORM (flag_present, DW_FORM_flag_present) \
DWARF_ONE_KNOWN_DW_FORM (implicit_const, DW_FORM_implicit_const) \
DWARF_ONE_KNOWN_DW_FORM (indirect, DW_FORM_indirect) \
DWARF_ONE_KNOWN_DW_FORM (line_strp, DW_FORM_line_strp) \
DWARF_ONE_KNOWN_DW_FORM (loclistx, DW_FORM_loclistx) \
DWARF_ONE_KNOWN_DW_FORM (ref1, DW_FORM_ref1) \
DWARF_ONE_KNOWN_DW_FORM (ref2, DW_FORM_ref2) \
DWARF_ONE_KNOWN_DW_FORM (ref4, DW_FORM_ref4) \
DWARF_ONE_KNOWN_DW_FORM (ref8, DW_FORM_ref8) \
DWARF_ONE_KNOWN_DW_FORM (ref_addr, DW_FORM_ref_addr) \
DWARF_ONE_KNOWN_DW_FORM (ref_sig8, DW_FORM_ref_sig8) \
DWARF_ONE_KNOWN_DW_FORM (ref_sup4, DW_FORM_ref_sup4) \
DWARF_ONE_KNOWN_DW_FORM (ref_sup8, DW_FORM_ref_sup8) \
DWARF_ONE_KNOWN_DW_FORM (ref_udata, DW_FORM_ref_udata) \
DWARF_ONE_KNOWN_DW_FORM (rnglistx, DW_FORM_rnglistx) \
DWARF_ONE_KNOWN_DW_FORM (sdata, DW_FORM_sdata) \
DWARF_ONE_KNOWN_DW_FORM (sec_offset, DW_FORM_sec_offset) \
DWARF_ONE_KNOWN_DW_FORM (string, DW_FORM_string) \
DWARF_ONE_KNOWN_DW_FORM (strp, DW_FORM_strp) \
DWARF_ONE_KNOWN_DW_FORM (strp_sup, DW_FORM_strp_sup) \
DWARF_ONE_KNOWN_DW_FORM (strx, DW_FORM_strx) \
DWARF_ONE_KNOWN_DW_FORM (strx1, DW_FORM_strx1) \
DWARF_ONE_KNOWN_DW_FORM (strx2, DW_FORM_strx2) \
DWARF_ONE_KNOWN_DW_FORM (strx3, DW_FORM_strx3) \
DWARF_ONE_KNOWN_DW_FORM (strx4, DW_FORM_strx4) \
DWARF_ONE_KNOWN_DW_FORM (udata, DW_FORM_udata) \
/* End of DW_FORM_*. */
#define DWARF_ALL_KNOWN_DW_ID \
DWARF_ONE_KNOWN_DW_ID (case_insensitive, DW_ID_case_insensitive) \
DWARF_ONE_KNOWN_DW_ID (case_sensitive, DW_ID_case_sensitive) \
DWARF_ONE_KNOWN_DW_ID (down_case, DW_ID_down_case) \
DWARF_ONE_KNOWN_DW_ID (up_case, DW_ID_up_case) \
/* End of DW_ID_*. */
#define DWARF_ALL_KNOWN_DW_INL \
DWARF_ONE_KNOWN_DW_INL (declared_inlined, DW_INL_declared_inlined) \
DWARF_ONE_KNOWN_DW_INL (declared_not_inlined, DW_INL_declared_not_inlined) \
DWARF_ONE_KNOWN_DW_INL (inlined, DW_INL_inlined) \
DWARF_ONE_KNOWN_DW_INL (not_inlined, DW_INL_not_inlined) \
/* End of DW_INL_*. */
#define DWARF_ALL_KNOWN_DW_LANG \
DWARF_ONE_KNOWN_DW_LANG (Ada83, DW_LANG_Ada83) \
DWARF_ONE_KNOWN_DW_LANG (Ada95, DW_LANG_Ada95) \
DWARF_ONE_KNOWN_DW_LANG (BLISS, DW_LANG_BLISS) \
DWARF_ONE_KNOWN_DW_LANG (C, DW_LANG_C) \
DWARF_ONE_KNOWN_DW_LANG (C11, DW_LANG_C11) \
DWARF_ONE_KNOWN_DW_LANG (C89, DW_LANG_C89) \
DWARF_ONE_KNOWN_DW_LANG (C99, DW_LANG_C99) \
DWARF_ONE_KNOWN_DW_LANG (C_plus_plus, DW_LANG_C_plus_plus) \
DWARF_ONE_KNOWN_DW_LANG (C_plus_plus_03, DW_LANG_C_plus_plus_03) \
DWARF_ONE_KNOWN_DW_LANG (C_plus_plus_11, DW_LANG_C_plus_plus_11) \
DWARF_ONE_KNOWN_DW_LANG (C_plus_plus_14, DW_LANG_C_plus_plus_14) \
DWARF_ONE_KNOWN_DW_LANG (Cobol74, DW_LANG_Cobol74) \
DWARF_ONE_KNOWN_DW_LANG (Cobol85, DW_LANG_Cobol85) \
DWARF_ONE_KNOWN_DW_LANG (D, DW_LANG_D) \
DWARF_ONE_KNOWN_DW_LANG (Dylan, DW_LANG_Dylan) \
DWARF_ONE_KNOWN_DW_LANG (Fortran03, DW_LANG_Fortran03) \
DWARF_ONE_KNOWN_DW_LANG (Fortran08, DW_LANG_Fortran08) \
DWARF_ONE_KNOWN_DW_LANG (Fortran77, DW_LANG_Fortran77) \
DWARF_ONE_KNOWN_DW_LANG (Fortran90, DW_LANG_Fortran90) \
DWARF_ONE_KNOWN_DW_LANG (Fortran95, DW_LANG_Fortran95) \
DWARF_ONE_KNOWN_DW_LANG (Go, DW_LANG_Go) \
DWARF_ONE_KNOWN_DW_LANG (Haskell, DW_LANG_Haskell) \
DWARF_ONE_KNOWN_DW_LANG (Java, DW_LANG_Java) \
DWARF_ONE_KNOWN_DW_LANG (Julia, DW_LANG_Julia) \
DWARF_ONE_KNOWN_DW_LANG (Mips_Assembler, DW_LANG_Mips_Assembler) \
DWARF_ONE_KNOWN_DW_LANG (Modula2, DW_LANG_Modula2) \
DWARF_ONE_KNOWN_DW_LANG (Modula3, DW_LANG_Modula3) \
DWARF_ONE_KNOWN_DW_LANG (OCaml, DW_LANG_OCaml) \
DWARF_ONE_KNOWN_DW_LANG (ObjC, DW_LANG_ObjC) \
DWARF_ONE_KNOWN_DW_LANG (ObjC_plus_plus, DW_LANG_ObjC_plus_plus) \
DWARF_ONE_KNOWN_DW_LANG (OpenCL, DW_LANG_OpenCL) \
DWARF_ONE_KNOWN_DW_LANG (PLI, DW_LANG_PLI) \
DWARF_ONE_KNOWN_DW_LANG (Pascal83, DW_LANG_Pascal83) \
DWARF_ONE_KNOWN_DW_LANG (Python, DW_LANG_Python) \
DWARF_ONE_KNOWN_DW_LANG (RenderScript, DW_LANG_RenderScript) \
DWARF_ONE_KNOWN_DW_LANG (Rust, DW_LANG_Rust) \
DWARF_ONE_KNOWN_DW_LANG (Swift, DW_LANG_Swift) \
DWARF_ONE_KNOWN_DW_LANG (UPC, DW_LANG_UPC) \
/* End of DW_LANG_*. */
#define DWARF_ALL_KNOWN_DW_LLE \
DWARF_ONE_KNOWN_DW_LLE (base_address, DW_LLE_base_address) \
DWARF_ONE_KNOWN_DW_LLE (base_addressx, DW_LLE_base_addressx) \
DWARF_ONE_KNOWN_DW_LLE (default_location, DW_LLE_default_location) \
DWARF_ONE_KNOWN_DW_LLE (end_of_list, DW_LLE_end_of_list) \
DWARF_ONE_KNOWN_DW_LLE (offset_pair, DW_LLE_offset_pair) \
DWARF_ONE_KNOWN_DW_LLE (start_end, DW_LLE_start_end) \
DWARF_ONE_KNOWN_DW_LLE (start_length, DW_LLE_start_length) \
DWARF_ONE_KNOWN_DW_LLE (startx_endx, DW_LLE_startx_endx) \
DWARF_ONE_KNOWN_DW_LLE (startx_length, DW_LLE_startx_length) \
/* End of DW_LLE_*. */
#define DWARF_ALL_KNOWN_DW_LLE_GNU \
DWARF_ONE_KNOWN_DW_LLE_GNU (base_address_selection_entry, DW_LLE_GNU_base_address_selection_entry) \
DWARF_ONE_KNOWN_DW_LLE_GNU (end_of_list_entry, DW_LLE_GNU_end_of_list_entry) \
DWARF_ONE_KNOWN_DW_LLE_GNU (start_end_entry, DW_LLE_GNU_start_end_entry) \
DWARF_ONE_KNOWN_DW_LLE_GNU (start_length_entry, DW_LLE_GNU_start_length_entry) \
DWARF_ONE_KNOWN_DW_LLE_GNU (view_pair, DW_LLE_GNU_view_pair) \
/* End of DW_LLE_GNU_*. */
#define DWARF_ALL_KNOWN_DW_LNCT \
DWARF_ONE_KNOWN_DW_LNCT (MD5, DW_LNCT_MD5) \
DWARF_ONE_KNOWN_DW_LNCT (directory_index, DW_LNCT_directory_index) \
DWARF_ONE_KNOWN_DW_LNCT (path, DW_LNCT_path) \
DWARF_ONE_KNOWN_DW_LNCT (size, DW_LNCT_size) \
DWARF_ONE_KNOWN_DW_LNCT (timestamp, DW_LNCT_timestamp) \
/* End of DW_LNCT_*. */
#define DWARF_ALL_KNOWN_DW_LNE \
DWARF_ONE_KNOWN_DW_LNE (NVIDIA_inlined_call, DW_LNE_NVIDIA_inlined_call) \
DWARF_ONE_KNOWN_DW_LNE (NVIDIA_set_function_name, DW_LNE_NVIDIA_set_function_name) \
DWARF_ONE_KNOWN_DW_LNE (define_file, DW_LNE_define_file) \
DWARF_ONE_KNOWN_DW_LNE (end_sequence, DW_LNE_end_sequence) \
DWARF_ONE_KNOWN_DW_LNE (set_address, DW_LNE_set_address) \
DWARF_ONE_KNOWN_DW_LNE (set_discriminator, DW_LNE_set_discriminator) \
/* End of DW_LNE_*. */
#define DWARF_ALL_KNOWN_DW_LNS \
DWARF_ONE_KNOWN_DW_LNS (advance_line, DW_LNS_advance_line) \
DWARF_ONE_KNOWN_DW_LNS (advance_pc, DW_LNS_advance_pc) \
DWARF_ONE_KNOWN_DW_LNS (const_add_pc, DW_LNS_const_add_pc) \
DWARF_ONE_KNOWN_DW_LNS (copy, DW_LNS_copy) \
DWARF_ONE_KNOWN_DW_LNS (fixed_advance_pc, DW_LNS_fixed_advance_pc) \
DWARF_ONE_KNOWN_DW_LNS (negate_stmt, DW_LNS_negate_stmt) \
DWARF_ONE_KNOWN_DW_LNS (set_basic_block, DW_LNS_set_basic_block) \
DWARF_ONE_KNOWN_DW_LNS (set_column, DW_LNS_set_column) \
DWARF_ONE_KNOWN_DW_LNS (set_epilogue_begin, DW_LNS_set_epilogue_begin) \
DWARF_ONE_KNOWN_DW_LNS (set_file, DW_LNS_set_file) \
DWARF_ONE_KNOWN_DW_LNS (set_isa, DW_LNS_set_isa) \
DWARF_ONE_KNOWN_DW_LNS (set_prologue_end, DW_LNS_set_prologue_end) \
/* End of DW_LNS_*. */
#define DWARF_ALL_KNOWN_DW_MACINFO \
DWARF_ONE_KNOWN_DW_MACINFO (define, DW_MACINFO_define) \
DWARF_ONE_KNOWN_DW_MACINFO (end_file, DW_MACINFO_end_file) \
DWARF_ONE_KNOWN_DW_MACINFO (start_file, DW_MACINFO_start_file) \
DWARF_ONE_KNOWN_DW_MACINFO (undef, DW_MACINFO_undef) \
DWARF_ONE_KNOWN_DW_MACINFO (vendor_ext, DW_MACINFO_vendor_ext) \
/* End of DW_MACINFO_*. */
#define DWARF_ALL_KNOWN_DW_MACRO \
DWARF_ONE_KNOWN_DW_MACRO (define, DW_MACRO_define) \
DWARF_ONE_KNOWN_DW_MACRO (define_strp, DW_MACRO_define_strp) \
DWARF_ONE_KNOWN_DW_MACRO (define_strx, DW_MACRO_define_strx) \
DWARF_ONE_KNOWN_DW_MACRO (define_sup, DW_MACRO_define_sup) \
DWARF_ONE_KNOWN_DW_MACRO (end_file, DW_MACRO_end_file) \
DWARF_ONE_KNOWN_DW_MACRO (import, DW_MACRO_import) \
DWARF_ONE_KNOWN_DW_MACRO (import_sup, DW_MACRO_import_sup) \
DWARF_ONE_KNOWN_DW_MACRO (start_file, DW_MACRO_start_file) \
DWARF_ONE_KNOWN_DW_MACRO (undef, DW_MACRO_undef) \
DWARF_ONE_KNOWN_DW_MACRO (undef_strp, DW_MACRO_undef_strp) \
DWARF_ONE_KNOWN_DW_MACRO (undef_strx, DW_MACRO_undef_strx) \
DWARF_ONE_KNOWN_DW_MACRO (undef_sup, DW_MACRO_undef_sup) \
/* End of DW_MACRO_*. */
#define DWARF_ALL_KNOWN_DW_OP \
DWARF_ONE_KNOWN_DW_OP (GNU_addr_index, DW_OP_GNU_addr_index) \
DWARF_ONE_KNOWN_DW_OP (GNU_const_index, DW_OP_GNU_const_index) \
DWARF_ONE_KNOWN_DW_OP (GNU_const_type, DW_OP_GNU_const_type) \
DWARF_ONE_KNOWN_DW_OP (GNU_convert, DW_OP_GNU_convert) \
DWARF_ONE_KNOWN_DW_OP (GNU_deref_type, DW_OP_GNU_deref_type) \
DWARF_ONE_KNOWN_DW_OP (GNU_encoded_addr, DW_OP_GNU_encoded_addr) \
DWARF_ONE_KNOWN_DW_OP (GNU_entry_value, DW_OP_GNU_entry_value) \
DWARF_ONE_KNOWN_DW_OP (GNU_implicit_pointer, DW_OP_GNU_implicit_pointer) \
DWARF_ONE_KNOWN_DW_OP (GNU_parameter_ref, DW_OP_GNU_parameter_ref) \
DWARF_ONE_KNOWN_DW_OP (GNU_push_tls_address, DW_OP_GNU_push_tls_address) \
DWARF_ONE_KNOWN_DW_OP (GNU_regval_type, DW_OP_GNU_regval_type) \
DWARF_ONE_KNOWN_DW_OP (GNU_reinterpret, DW_OP_GNU_reinterpret) \
DWARF_ONE_KNOWN_DW_OP (GNU_uninit, DW_OP_GNU_uninit) \
DWARF_ONE_KNOWN_DW_OP (GNU_variable_value, DW_OP_GNU_variable_value) \
DWARF_ONE_KNOWN_DW_OP (abs, DW_OP_abs) \
DWARF_ONE_KNOWN_DW_OP (addr, DW_OP_addr) \
DWARF_ONE_KNOWN_DW_OP (addrx, DW_OP_addrx) \
DWARF_ONE_KNOWN_DW_OP (and, DW_OP_and) \
DWARF_ONE_KNOWN_DW_OP (bit_piece, DW_OP_bit_piece) \
DWARF_ONE_KNOWN_DW_OP (bra, DW_OP_bra) \
DWARF_ONE_KNOWN_DW_OP (breg0, DW_OP_breg0) \
DWARF_ONE_KNOWN_DW_OP (breg1, DW_OP_breg1) \
DWARF_ONE_KNOWN_DW_OP (breg10, DW_OP_breg10) \
DWARF_ONE_KNOWN_DW_OP (breg11, DW_OP_breg11) \
DWARF_ONE_KNOWN_DW_OP (breg12, DW_OP_breg12) \
DWARF_ONE_KNOWN_DW_OP (breg13, DW_OP_breg13) \
DWARF_ONE_KNOWN_DW_OP (breg14, DW_OP_breg14) \
DWARF_ONE_KNOWN_DW_OP (breg15, DW_OP_breg15) \
DWARF_ONE_KNOWN_DW_OP (breg16, DW_OP_breg16) \
DWARF_ONE_KNOWN_DW_OP (breg17, DW_OP_breg17) \
DWARF_ONE_KNOWN_DW_OP (breg18, DW_OP_breg18) \
DWARF_ONE_KNOWN_DW_OP (breg19, DW_OP_breg19) \
DWARF_ONE_KNOWN_DW_OP (breg2, DW_OP_breg2) \
DWARF_ONE_KNOWN_DW_OP (breg20, DW_OP_breg20) \
DWARF_ONE_KNOWN_DW_OP (breg21, DW_OP_breg21) \
DWARF_ONE_KNOWN_DW_OP (breg22, DW_OP_breg22) \
DWARF_ONE_KNOWN_DW_OP (breg23, DW_OP_breg23) \
DWARF_ONE_KNOWN_DW_OP (breg24, DW_OP_breg24) \
DWARF_ONE_KNOWN_DW_OP (breg25, DW_OP_breg25) \
DWARF_ONE_KNOWN_DW_OP (breg26, DW_OP_breg26) \
DWARF_ONE_KNOWN_DW_OP (breg27, DW_OP_breg27) \
DWARF_ONE_KNOWN_DW_OP (breg28, DW_OP_breg28) \
DWARF_ONE_KNOWN_DW_OP (breg29, DW_OP_breg29) \
DWARF_ONE_KNOWN_DW_OP (breg3, DW_OP_breg3) \
DWARF_ONE_KNOWN_DW_OP (breg30, DW_OP_breg30) \
DWARF_ONE_KNOWN_DW_OP (breg31, DW_OP_breg31) \
DWARF_ONE_KNOWN_DW_OP (breg4, DW_OP_breg4) \
DWARF_ONE_KNOWN_DW_OP (breg5, DW_OP_breg5) \
DWARF_ONE_KNOWN_DW_OP (breg6, DW_OP_breg6) \
DWARF_ONE_KNOWN_DW_OP (breg7, DW_OP_breg7) \
DWARF_ONE_KNOWN_DW_OP (breg8, DW_OP_breg8) \
DWARF_ONE_KNOWN_DW_OP (breg9, DW_OP_breg9) \
DWARF_ONE_KNOWN_DW_OP (bregx, DW_OP_bregx) \
DWARF_ONE_KNOWN_DW_OP (call2, DW_OP_call2) \
DWARF_ONE_KNOWN_DW_OP (call4, DW_OP_call4) \
DWARF_ONE_KNOWN_DW_OP (call_frame_cfa, DW_OP_call_frame_cfa) \
DWARF_ONE_KNOWN_DW_OP (call_ref, DW_OP_call_ref) \
DWARF_ONE_KNOWN_DW_OP (const1s, DW_OP_const1s) \
DWARF_ONE_KNOWN_DW_OP (const1u, DW_OP_const1u) \
DWARF_ONE_KNOWN_DW_OP (const2s, DW_OP_const2s) \
DWARF_ONE_KNOWN_DW_OP (const2u, DW_OP_const2u) \
DWARF_ONE_KNOWN_DW_OP (const4s, DW_OP_const4s) \
DWARF_ONE_KNOWN_DW_OP (const4u, DW_OP_const4u) \
DWARF_ONE_KNOWN_DW_OP (const8s, DW_OP_const8s) \
DWARF_ONE_KNOWN_DW_OP (const8u, DW_OP_const8u) \
DWARF_ONE_KNOWN_DW_OP (const_type, DW_OP_const_type) \
DWARF_ONE_KNOWN_DW_OP (consts, DW_OP_consts) \
DWARF_ONE_KNOWN_DW_OP (constu, DW_OP_constu) \
DWARF_ONE_KNOWN_DW_OP (constx, DW_OP_constx) \
DWARF_ONE_KNOWN_DW_OP (convert, DW_OP_convert) \
DWARF_ONE_KNOWN_DW_OP (deref, DW_OP_deref) \
DWARF_ONE_KNOWN_DW_OP (deref_size, DW_OP_deref_size) \
DWARF_ONE_KNOWN_DW_OP (deref_type, DW_OP_deref_type) \
DWARF_ONE_KNOWN_DW_OP (div, DW_OP_div) \
DWARF_ONE_KNOWN_DW_OP (drop, DW_OP_drop) \
DWARF_ONE_KNOWN_DW_OP (dup, DW_OP_dup) \
DWARF_ONE_KNOWN_DW_OP (entry_value, DW_OP_entry_value) \
DWARF_ONE_KNOWN_DW_OP (eq, DW_OP_eq) \
DWARF_ONE_KNOWN_DW_OP (fbreg, DW_OP_fbreg) \
DWARF_ONE_KNOWN_DW_OP (form_tls_address, DW_OP_form_tls_address) \
DWARF_ONE_KNOWN_DW_OP (ge, DW_OP_ge) \
DWARF_ONE_KNOWN_DW_OP (gt, DW_OP_gt) \
DWARF_ONE_KNOWN_DW_OP (implicit_pointer, DW_OP_implicit_pointer) \
DWARF_ONE_KNOWN_DW_OP (implicit_value, DW_OP_implicit_value) \
DWARF_ONE_KNOWN_DW_OP (le, DW_OP_le) \
DWARF_ONE_KNOWN_DW_OP (lit0, DW_OP_lit0) \
DWARF_ONE_KNOWN_DW_OP (lit1, DW_OP_lit1) \
DWARF_ONE_KNOWN_DW_OP (lit10, DW_OP_lit10) \
DWARF_ONE_KNOWN_DW_OP (lit11, DW_OP_lit11) \
DWARF_ONE_KNOWN_DW_OP (lit12, DW_OP_lit12) \
DWARF_ONE_KNOWN_DW_OP (lit13, DW_OP_lit13) \
DWARF_ONE_KNOWN_DW_OP (lit14, DW_OP_lit14) \
DWARF_ONE_KNOWN_DW_OP (lit15, DW_OP_lit15) \
DWARF_ONE_KNOWN_DW_OP (lit16, DW_OP_lit16) \
DWARF_ONE_KNOWN_DW_OP (lit17, DW_OP_lit17) \
DWARF_ONE_KNOWN_DW_OP (lit18, DW_OP_lit18) \
DWARF_ONE_KNOWN_DW_OP (lit19, DW_OP_lit19) \
DWARF_ONE_KNOWN_DW_OP (lit2, DW_OP_lit2) \
DWARF_ONE_KNOWN_DW_OP (lit20, DW_OP_lit20) \
DWARF_ONE_KNOWN_DW_OP (lit21, DW_OP_lit21) \
DWARF_ONE_KNOWN_DW_OP (lit22, DW_OP_lit22) \
DWARF_ONE_KNOWN_DW_OP (lit23, DW_OP_lit23) \
DWARF_ONE_KNOWN_DW_OP (lit24, DW_OP_lit24) \
DWARF_ONE_KNOWN_DW_OP (lit25, DW_OP_lit25) \
DWARF_ONE_KNOWN_DW_OP (lit26, DW_OP_lit26) \
DWARF_ONE_KNOWN_DW_OP (lit27, DW_OP_lit27) \
DWARF_ONE_KNOWN_DW_OP (lit28, DW_OP_lit28) \
DWARF_ONE_KNOWN_DW_OP (lit29, DW_OP_lit29) \
DWARF_ONE_KNOWN_DW_OP (lit3, DW_OP_lit3) \
DWARF_ONE_KNOWN_DW_OP (lit30, DW_OP_lit30) \
DWARF_ONE_KNOWN_DW_OP (lit31, DW_OP_lit31) \
DWARF_ONE_KNOWN_DW_OP (lit4, DW_OP_lit4) \
DWARF_ONE_KNOWN_DW_OP (lit5, DW_OP_lit5) \
DWARF_ONE_KNOWN_DW_OP (lit6, DW_OP_lit6) \
DWARF_ONE_KNOWN_DW_OP (lit7, DW_OP_lit7) \
DWARF_ONE_KNOWN_DW_OP (lit8, DW_OP_lit8) \
DWARF_ONE_KNOWN_DW_OP (lit9, DW_OP_lit9) \
DWARF_ONE_KNOWN_DW_OP (lt, DW_OP_lt) \
DWARF_ONE_KNOWN_DW_OP (minus, DW_OP_minus) \
DWARF_ONE_KNOWN_DW_OP (mod, DW_OP_mod) \
DWARF_ONE_KNOWN_DW_OP (mul, DW_OP_mul) \
DWARF_ONE_KNOWN_DW_OP (ne, DW_OP_ne) \
DWARF_ONE_KNOWN_DW_OP (neg, DW_OP_neg) \
DWARF_ONE_KNOWN_DW_OP (nop, DW_OP_nop) \
DWARF_ONE_KNOWN_DW_OP (not, DW_OP_not) \
DWARF_ONE_KNOWN_DW_OP (or, DW_OP_or) \
DWARF_ONE_KNOWN_DW_OP (over, DW_OP_over) \
DWARF_ONE_KNOWN_DW_OP (pick, DW_OP_pick) \
DWARF_ONE_KNOWN_DW_OP (piece, DW_OP_piece) \
DWARF_ONE_KNOWN_DW_OP (plus, DW_OP_plus) \
DWARF_ONE_KNOWN_DW_OP (plus_uconst, DW_OP_plus_uconst) \
DWARF_ONE_KNOWN_DW_OP (push_object_address, DW_OP_push_object_address) \
DWARF_ONE_KNOWN_DW_OP (reg0, DW_OP_reg0) \
DWARF_ONE_KNOWN_DW_OP (reg1, DW_OP_reg1) \
DWARF_ONE_KNOWN_DW_OP (reg10, DW_OP_reg10) \
DWARF_ONE_KNOWN_DW_OP (reg11, DW_OP_reg11) \
DWARF_ONE_KNOWN_DW_OP (reg12, DW_OP_reg12) \
DWARF_ONE_KNOWN_DW_OP (reg13, DW_OP_reg13) \
DWARF_ONE_KNOWN_DW_OP (reg14, DW_OP_reg14) \
DWARF_ONE_KNOWN_DW_OP (reg15, DW_OP_reg15) \
DWARF_ONE_KNOWN_DW_OP (reg16, DW_OP_reg16) \
DWARF_ONE_KNOWN_DW_OP (reg17, DW_OP_reg17) \
DWARF_ONE_KNOWN_DW_OP (reg18, DW_OP_reg18) \
DWARF_ONE_KNOWN_DW_OP (reg19, DW_OP_reg19) \
DWARF_ONE_KNOWN_DW_OP (reg2, DW_OP_reg2) \
DWARF_ONE_KNOWN_DW_OP (reg20, DW_OP_reg20) \
DWARF_ONE_KNOWN_DW_OP (reg21, DW_OP_reg21) \
DWARF_ONE_KNOWN_DW_OP (reg22, DW_OP_reg22) \
DWARF_ONE_KNOWN_DW_OP (reg23, DW_OP_reg23) \
DWARF_ONE_KNOWN_DW_OP (reg24, DW_OP_reg24) \
DWARF_ONE_KNOWN_DW_OP (reg25, DW_OP_reg25) \
DWARF_ONE_KNOWN_DW_OP (reg26, DW_OP_reg26) \
DWARF_ONE_KNOWN_DW_OP (reg27, DW_OP_reg27) \
DWARF_ONE_KNOWN_DW_OP (reg28, DW_OP_reg28) \
DWARF_ONE_KNOWN_DW_OP (reg29, DW_OP_reg29) \
DWARF_ONE_KNOWN_DW_OP (reg3, DW_OP_reg3) \
DWARF_ONE_KNOWN_DW_OP (reg30, DW_OP_reg30) \
DWARF_ONE_KNOWN_DW_OP (reg31, DW_OP_reg31) \
DWARF_ONE_KNOWN_DW_OP (reg4, DW_OP_reg4) \
DWARF_ONE_KNOWN_DW_OP (reg5, DW_OP_reg5) \
DWARF_ONE_KNOWN_DW_OP (reg6, DW_OP_reg6) \
DWARF_ONE_KNOWN_DW_OP (reg7, DW_OP_reg7) \
DWARF_ONE_KNOWN_DW_OP (reg8, DW_OP_reg8) \
DWARF_ONE_KNOWN_DW_OP (reg9, DW_OP_reg9) \
DWARF_ONE_KNOWN_DW_OP (regval_type, DW_OP_regval_type) \
DWARF_ONE_KNOWN_DW_OP (regx, DW_OP_regx) \
DWARF_ONE_KNOWN_DW_OP (reinterpret, DW_OP_reinterpret) \
DWARF_ONE_KNOWN_DW_OP (rot, DW_OP_rot) \
DWARF_ONE_KNOWN_DW_OP (shl, DW_OP_shl) \
DWARF_ONE_KNOWN_DW_OP (shr, DW_OP_shr) \
DWARF_ONE_KNOWN_DW_OP (shra, DW_OP_shra) \
DWARF_ONE_KNOWN_DW_OP (skip, DW_OP_skip) \
DWARF_ONE_KNOWN_DW_OP (stack_value, DW_OP_stack_value) \
DWARF_ONE_KNOWN_DW_OP (swap, DW_OP_swap) \
DWARF_ONE_KNOWN_DW_OP (xderef, DW_OP_xderef) \
DWARF_ONE_KNOWN_DW_OP (xderef_size, DW_OP_xderef_size) \
DWARF_ONE_KNOWN_DW_OP (xderef_type, DW_OP_xderef_type) \
DWARF_ONE_KNOWN_DW_OP (xor, DW_OP_xor) \
/* End of DW_OP_*. */
#define DWARF_ALL_KNOWN_DW_ORD \
DWARF_ONE_KNOWN_DW_ORD (col_major, DW_ORD_col_major) \
DWARF_ONE_KNOWN_DW_ORD (row_major, DW_ORD_row_major) \
/* End of DW_ORD_*. */
#define DWARF_ALL_KNOWN_DW_RLE \
DWARF_ONE_KNOWN_DW_RLE (base_address, DW_RLE_base_address) \
DWARF_ONE_KNOWN_DW_RLE (base_addressx, DW_RLE_base_addressx) \
DWARF_ONE_KNOWN_DW_RLE (end_of_list, DW_RLE_end_of_list) \
DWARF_ONE_KNOWN_DW_RLE (offset_pair, DW_RLE_offset_pair) \
DWARF_ONE_KNOWN_DW_RLE (start_end, DW_RLE_start_end) \
DWARF_ONE_KNOWN_DW_RLE (start_length, DW_RLE_start_length) \
DWARF_ONE_KNOWN_DW_RLE (startx_endx, DW_RLE_startx_endx) \
DWARF_ONE_KNOWN_DW_RLE (startx_length, DW_RLE_startx_length) \
/* End of DW_RLE_*. */
#define DWARF_ALL_KNOWN_DW_SECT_INFO \
DWARF_ONE_KNOWN_DW_SECT_INFO (, DW_SECT_INFO_) \
DWARF_ONE_KNOWN_DW_SECT_INFO (, DW_SECT_INFO_) \
DWARF_ONE_KNOWN_DW_SECT_INFO (, DW_SECT_INFO_) \
DWARF_ONE_KNOWN_DW_SECT_INFO (, DW_SECT_INFO_) \
DWARF_ONE_KNOWN_DW_SECT_INFO (, DW_SECT_INFO_) \
DWARF_ONE_KNOWN_DW_SECT_INFO (, DW_SECT_INFO_) \
DWARF_ONE_KNOWN_DW_SECT_INFO (, DW_SECT_INFO_) \
/* End of DW_SECT_INFO_*. */
#define DWARF_ALL_KNOWN_DW_TAG \
DWARF_ONE_KNOWN_DW_TAG (GNU_BINCL, DW_TAG_GNU_BINCL) \
DWARF_ONE_KNOWN_DW_TAG (GNU_EINCL, DW_TAG_GNU_EINCL) \
DWARF_ONE_KNOWN_DW_TAG (GNU_call_site, DW_TAG_GNU_call_site) \
DWARF_ONE_KNOWN_DW_TAG (GNU_call_site_parameter, DW_TAG_GNU_call_site_parameter) \
DWARF_ONE_KNOWN_DW_TAG (GNU_formal_parameter_pack, DW_TAG_GNU_formal_parameter_pack) \
DWARF_ONE_KNOWN_DW_TAG (GNU_template_parameter_pack, DW_TAG_GNU_template_parameter_pack) \
DWARF_ONE_KNOWN_DW_TAG (GNU_template_template_param, DW_TAG_GNU_template_template_param) \
DWARF_ONE_KNOWN_DW_TAG (MIPS_loop, DW_TAG_MIPS_loop) \
DWARF_ONE_KNOWN_DW_TAG (access_declaration, DW_TAG_access_declaration) \
DWARF_ONE_KNOWN_DW_TAG (array_type, DW_TAG_array_type) \
DWARF_ONE_KNOWN_DW_TAG (atomic_type, DW_TAG_atomic_type) \
DWARF_ONE_KNOWN_DW_TAG (base_type, DW_TAG_base_type) \
DWARF_ONE_KNOWN_DW_TAG (call_site, DW_TAG_call_site) \
DWARF_ONE_KNOWN_DW_TAG (call_site_parameter, DW_TAG_call_site_parameter) \
DWARF_ONE_KNOWN_DW_TAG (catch_block, DW_TAG_catch_block) \
DWARF_ONE_KNOWN_DW_TAG (class_template, DW_TAG_class_template) \
DWARF_ONE_KNOWN_DW_TAG (class_type, DW_TAG_class_type) \
DWARF_ONE_KNOWN_DW_TAG (coarray_type, DW_TAG_coarray_type) \
DWARF_ONE_KNOWN_DW_TAG (common_block, DW_TAG_common_block) \
DWARF_ONE_KNOWN_DW_TAG (common_inclusion, DW_TAG_common_inclusion) \
DWARF_ONE_KNOWN_DW_TAG (compile_unit, DW_TAG_compile_unit) \
DWARF_ONE_KNOWN_DW_TAG (condition, DW_TAG_condition) \
DWARF_ONE_KNOWN_DW_TAG (const_type, DW_TAG_const_type) \
DWARF_ONE_KNOWN_DW_TAG (constant, DW_TAG_constant) \
DWARF_ONE_KNOWN_DW_TAG (dwarf_procedure, DW_TAG_dwarf_procedure) \
DWARF_ONE_KNOWN_DW_TAG (dynamic_type, DW_TAG_dynamic_type) \
DWARF_ONE_KNOWN_DW_TAG (entry_point, DW_TAG_entry_point) \
DWARF_ONE_KNOWN_DW_TAG (enumeration_type, DW_TAG_enumeration_type) \
DWARF_ONE_KNOWN_DW_TAG (enumerator, DW_TAG_enumerator) \
DWARF_ONE_KNOWN_DW_TAG (file_type, DW_TAG_file_type) \
DWARF_ONE_KNOWN_DW_TAG (formal_parameter, DW_TAG_formal_parameter) \
DWARF_ONE_KNOWN_DW_TAG (format_label, DW_TAG_format_label) \
DWARF_ONE_KNOWN_DW_TAG (friend, DW_TAG_friend) \
DWARF_ONE_KNOWN_DW_TAG (function_template, DW_TAG_function_template) \
DWARF_ONE_KNOWN_DW_TAG (generic_subrange, DW_TAG_generic_subrange) \
DWARF_ONE_KNOWN_DW_TAG (immutable_type, DW_TAG_immutable_type) \
DWARF_ONE_KNOWN_DW_TAG (imported_declaration, DW_TAG_imported_declaration) \
DWARF_ONE_KNOWN_DW_TAG (imported_module, DW_TAG_imported_module) \
DWARF_ONE_KNOWN_DW_TAG (imported_unit, DW_TAG_imported_unit) \
DWARF_ONE_KNOWN_DW_TAG (inheritance, DW_TAG_inheritance) \
DWARF_ONE_KNOWN_DW_TAG (inlined_subroutine, DW_TAG_inlined_subroutine) \
DWARF_ONE_KNOWN_DW_TAG (interface_type, DW_TAG_interface_type) \
DWARF_ONE_KNOWN_DW_TAG (label, DW_TAG_label) \
DWARF_ONE_KNOWN_DW_TAG (lexical_block, DW_TAG_lexical_block) \
DWARF_ONE_KNOWN_DW_TAG (member, DW_TAG_member) \
DWARF_ONE_KNOWN_DW_TAG (module, DW_TAG_module) \
DWARF_ONE_KNOWN_DW_TAG (namelist, DW_TAG_namelist) \
DWARF_ONE_KNOWN_DW_TAG (namelist_item, DW_TAG_namelist_item) \
DWARF_ONE_KNOWN_DW_TAG (namespace, DW_TAG_namespace) \
DWARF_ONE_KNOWN_DW_TAG (packed_type, DW_TAG_packed_type) \
DWARF_ONE_KNOWN_DW_TAG (partial_unit, DW_TAG_partial_unit) \
DWARF_ONE_KNOWN_DW_TAG (pointer_type, DW_TAG_pointer_type) \
DWARF_ONE_KNOWN_DW_TAG (ptr_to_member_type, DW_TAG_ptr_to_member_type) \
DWARF_ONE_KNOWN_DW_TAG (reference_type, DW_TAG_reference_type) \
DWARF_ONE_KNOWN_DW_TAG (restrict_type, DW_TAG_restrict_type) \
DWARF_ONE_KNOWN_DW_TAG (rvalue_reference_type, DW_TAG_rvalue_reference_type) \
DWARF_ONE_KNOWN_DW_TAG (set_type, DW_TAG_set_type) \
DWARF_ONE_KNOWN_DW_TAG (shared_type, DW_TAG_shared_type) \
DWARF_ONE_KNOWN_DW_TAG (skeleton_unit, DW_TAG_skeleton_unit) \
DWARF_ONE_KNOWN_DW_TAG (string_type, DW_TAG_string_type) \
DWARF_ONE_KNOWN_DW_TAG (structure_type, DW_TAG_structure_type) \
DWARF_ONE_KNOWN_DW_TAG (subprogram, DW_TAG_subprogram) \
DWARF_ONE_KNOWN_DW_TAG (subrange_type, DW_TAG_subrange_type) \
DWARF_ONE_KNOWN_DW_TAG (subroutine_type, DW_TAG_subroutine_type) \
DWARF_ONE_KNOWN_DW_TAG (template_alias, DW_TAG_template_alias) \
DWARF_ONE_KNOWN_DW_TAG (template_type_parameter, DW_TAG_template_type_parameter) \
DWARF_ONE_KNOWN_DW_TAG (template_value_parameter, DW_TAG_template_value_parameter) \
DWARF_ONE_KNOWN_DW_TAG (thrown_type, DW_TAG_thrown_type) \
DWARF_ONE_KNOWN_DW_TAG (try_block, DW_TAG_try_block) \
DWARF_ONE_KNOWN_DW_TAG (type_unit, DW_TAG_type_unit) \
DWARF_ONE_KNOWN_DW_TAG (typedef, DW_TAG_typedef) \
DWARF_ONE_KNOWN_DW_TAG (union_type, DW_TAG_union_type) \
DWARF_ONE_KNOWN_DW_TAG (unspecified_parameters, DW_TAG_unspecified_parameters) \
DWARF_ONE_KNOWN_DW_TAG (unspecified_type, DW_TAG_unspecified_type) \
DWARF_ONE_KNOWN_DW_TAG (variable, DW_TAG_variable) \
DWARF_ONE_KNOWN_DW_TAG (variant, DW_TAG_variant) \
DWARF_ONE_KNOWN_DW_TAG (variant_part, DW_TAG_variant_part) \
DWARF_ONE_KNOWN_DW_TAG (volatile_type, DW_TAG_volatile_type) \
DWARF_ONE_KNOWN_DW_TAG (with_stmt, DW_TAG_with_stmt) \
/* End of DW_TAG_*. */
#define DWARF_ALL_KNOWN_DW_UT \
DWARF_ONE_KNOWN_DW_UT (compile, DW_UT_compile) \
DWARF_ONE_KNOWN_DW_UT (partial, DW_UT_partial) \
DWARF_ONE_KNOWN_DW_UT (skeleton, DW_UT_skeleton) \
DWARF_ONE_KNOWN_DW_UT (split_compile, DW_UT_split_compile) \
DWARF_ONE_KNOWN_DW_UT (split_type, DW_UT_split_type) \
DWARF_ONE_KNOWN_DW_UT (type, DW_UT_type) \
/* End of DW_UT_*. */
#define DWARF_ALL_KNOWN_DW_VIRTUALITY \
DWARF_ONE_KNOWN_DW_VIRTUALITY (none, DW_VIRTUALITY_none) \
DWARF_ONE_KNOWN_DW_VIRTUALITY (pure_virtual, DW_VIRTUALITY_pure_virtual) \
DWARF_ONE_KNOWN_DW_VIRTUALITY (virtual, DW_VIRTUALITY_virtual) \
/* End of DW_VIRTUALITY_*. */
#define DWARF_ALL_KNOWN_DW_VIS \
DWARF_ONE_KNOWN_DW_VIS (exported, DW_VIS_exported) \
DWARF_ONE_KNOWN_DW_VIS (local, DW_VIS_local) \
DWARF_ONE_KNOWN_DW_VIS (qualified, DW_VIS_qualified) \
/* End of DW_VIS_*. */
PK �zFZ$�s� � version.hnu �[��� /* Version information about elfutils development libraries.
Copyright (C) 2008 Red Hat, Inc.
This file is part of elfutils.
This file is free software; you can redistribute it and/or modify
it under the terms of either
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at
your option) any later version
or
* the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at
your option) any later version
or both in parallel, as here.
elfutils 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 for more details.
You should have received copies of the GNU General Public License and
the GNU Lesser General Public License along with this program. If
not, see <http://www.gnu.org/licenses/>. */
#ifndef _ELFUTILS_VERSION_H
#define _ELFUTILS_VERSION_H 1
#define _ELFUTILS_VERSION 190
#define _ELFUTILS_PREREQ(major, minor) \
(_ELFUTILS_VERSION >= ((major) * 1000 + (minor)))
#endif /* elfutils/version.h */
PK �zFZ8��6 6
libdwelf.hnu �[��� /* Interfaces for libdwelf. DWARF ELF Low-level Functions.
Copyright (C) 2014, 2015, 2016, 2018 Red Hat, Inc.
This file is part of elfutils.
This file is free software; you can redistribute it and/or modify
it under the terms of either
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at
your option) any later version
or
* the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at
your option) any later version
or both in parallel, as here.
elfutils 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 for more details.
You should have received copies of the GNU General Public License and
the GNU Lesser General Public License along with this program. If
not, see <http://www.gnu.org/licenses/>. */
#ifndef _LIBDWELF_H
#define _LIBDWELF_H 1
#include "libdw.h"
#ifdef __cplusplus
extern "C" {
#endif
/* DWARF ELF Low-level Functions (dwelf).
Functions starting with dwelf_elf will take a (libelf) Elf object as
first argument and might set elf_errno on error. Functions starting
with dwelf_dwarf will take a (libdw) Dwarf object as first argument
and might set dwarf_errno on error. */
/* Returns the name and the CRC32 of the separate debug file from the
.gnu_debuglink section if found in the ELF. Return NULL if the ELF
file didn't have a .gnu_debuglink section, had malformed data in the
section or some other error occurred. */
extern const char *dwelf_elf_gnu_debuglink (Elf *elf, GElf_Word *crc);
/* Returns the name and build ID from the .gnu_debugaltlink section if
found in the ELF. On success, pointers to the name and build ID
are written to *NAMEP and *BUILDID_P, and the positive length of
the build ID is returned. Returns 0 if the ELF lacks a
.gnu_debugaltlink section. Returns -1 in case of malformed data or
other errors. */
extern ssize_t dwelf_dwarf_gnu_debugaltlink (Dwarf *dwarf,
const char **namep,
const void **build_idp);
/* Returns the build ID as found in a NT_GNU_BUILD_ID note from either
a SHT_NOTE section or from a PT_NOTE segment if the ELF file
doesn't contain any section headers. On success a pointer to the
build ID is written to *BUILDID_P, and the positive length of the
build ID is returned. Returns 0 if the ELF lacks a NT_GNU_BUILD_ID
note. Returns -1 in case of malformed data or other errors. */
extern ssize_t dwelf_elf_gnu_build_id (Elf *elf, const void **build_idp);
/* Returns the size of the uncompressed data of a GNU compressed
section. The section name should start with .zdebug (but this
isn't checked by this function). If the section isn't compressed
(the section data doesn't start with ZLIB) -1 is returned. If an
error occurred -1 is returned and elf_errno is set. */
extern ssize_t dwelf_scn_gnu_compressed_size (Elf_Scn *scn);
/* ELF/DWARF string table handling. */
typedef struct Dwelf_Strtab Dwelf_Strtab;
typedef struct Dwelf_Strent Dwelf_Strent;
/* Create a new ELF/DWARF string table object in memory. ELF string
tables have a required zero length null string at offset zero.
DWARF string tables don't require such a null entry (unless they
are shared with an ELF string table). If NULLSTR is true then a
null entry is always created (even if the string table is empty
otherwise). */
extern Dwelf_Strtab *dwelf_strtab_init (bool nullstr);
/* Add string STR to string table ST. Returns NULL if no memory could
be allocated. The given STR is owned by the called and must be
valid till dwelf_strtab_free is called. dwelf_strtab_finalize
might copy the string into the final table and dwelf_strent_str
might return it, or a reference to an identical copy/substring
added to the string table. */
extern Dwelf_Strent *dwelf_strtab_add (Dwelf_Strtab *st, const char *str)
__nonnull_attribute__ (1, 2);
/* This is an optimized version of dwelf_strtab_add if the length of
the string is already known. LEN is the length of STR including
zero terminator. Calling dwelf_strtab_add (st, str) is similar to
calling dwelf_strtab_len (st, str, strlen (str) + 1). */
extern Dwelf_Strent *dwelf_strtab_add_len (Dwelf_Strtab *st,
const char *str, size_t len)
__nonnull_attribute__ (1, 2);
/* Finalize string table ST and store size and memory location
information in DATA d_size and d_buf. DATA d_type will be set to
ELF_T_BYTE, d_off will be zero, d_align will be 1 and d_version
will be set to EV_CURRENT. If no memory could be allocated NULL is
returned and DATA->d_buf will be set to NULL. Otherwise DATA will
be returned. */
extern Elf_Data *dwelf_strtab_finalize (Dwelf_Strtab *st,
Elf_Data *data)
__nonnull_attribute__ (1, 2);
/* Get offset in string table for string associated with entry. Only
valid after dwelf_strtab_finalize has been called. */
extern size_t dwelf_strent_off (Dwelf_Strent *se)
__nonnull_attribute__ (1);
/* Return the string associated with the entry. */
extern const char *dwelf_strent_str (Dwelf_Strent *se)
__nonnull_attribute__ (1);
/* Free resources allocated for the string table. This invalidates
any Dwelf_Strent references returned earlier. */
extern void dwelf_strtab_free (Dwelf_Strtab *st)
__nonnull_attribute__ (1);
/* Creates a read-only Elf handle from the given file handle. The
file may be compressed and/or contain a linux kernel image header,
in which case it is eagerly decompressed in full and the Elf handle
is created as if created with elf_memory (). On decompression or
file errors NULL is returned (and elf_errno will be set). If there
was no error, but the file is not an ELF file, then an ELF_K_NONE
Elf handle is returned (just like with elf_begin). The Elf handle
should be closed with elf_end (). The file handle will not be
closed. */
extern Elf *dwelf_elf_begin (int fd);
/* Returns a human readable string for the given ELF header e_machine
value, or NULL if the given number isn't currently known. */
extern const char *dwelf_elf_e_machine_string (int machine);
#ifdef __cplusplus
}
#endif
#endif /* libdwelf.h */
PK �zFZ����� � libasm.hnu �[��� /* Interface for libasm.
Copyright (C) 2002, 2005, 2008 Red Hat, Inc.
This file is part of elfutils.
This file is free software; you can redistribute it and/or modify
it under the terms of either
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at
your option) any later version
or
* the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at
your option) any later version
or both in parallel, as here.
elfutils 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 for more details.
You should have received copies of the GNU General Public License and
the GNU Lesser General Public License along with this program. If
not, see <http://www.gnu.org/licenses/>. */
#ifndef _LIBASM_H
#define _LIBASM_H 1
#include <stdbool.h>
#include <stdint.h>
#include <gelf.h>
typedef struct ebl Ebl;
/* Opaque type for the assembler context descriptor. */
typedef struct AsmCtx AsmCtx_t;
/* Opaque type for a section. */
typedef struct AsmScn AsmScn_t;
/* Opaque type for a section group. */
typedef struct AsmScnGrp AsmScnGrp_t;
/* Opaque type for a symbol. */
typedef struct AsmSym AsmSym_t;
/* Opaque type for the disassembler context descriptor. */
typedef struct DisasmCtx DisasmCtx_t;
/* Type used for callback functions to retrieve symbol name. The
symbol reference is in the section designated by the second parameter
at an offset described by the first parameter. The value is the
third parameter. */
typedef int (*DisasmGetSymCB_t) (GElf_Addr, Elf32_Word, GElf_Addr, char **,
size_t *, void *);
/* Output function callback. */
typedef int (*DisasmOutputCB_t) (char *, size_t, void *);
#ifdef __cplusplus
extern "C" {
#endif
/* Create output file and return descriptor for assembler context. If
TEXTP is true the output is an assembler format text file.
Otherwise an object file is created. The MACHINE parameter
corresponds to an EM_ constant from <elf.h>, KLASS specifies the
class (32- or 64-bit), and DATA specifies the byte order (little or
big endian). */
extern AsmCtx_t *asm_begin (const char *fname, Ebl *ebl, bool textp);
/* Abort the operation on the assembler context and free all resources. */
extern int asm_abort (AsmCtx_t *ctx);
/* Finalize output file and free all resources. */
extern int asm_end (AsmCtx_t *ctx);
/* Return handle for the named section. If it was not used before
create it. */
extern AsmScn_t *asm_newscn (AsmCtx_t *ctx, const char *scnname,
GElf_Word type, GElf_Xword flags);
/* Similar to 'asm_newscn', but make it part of section group GRP. */
extern AsmScn_t *asm_newscn_ingrp (AsmCtx_t *ctx, const char *scnname,
GElf_Word type, GElf_Xword flags,
AsmScnGrp_t *grp);
/* Create new subsection NR in the given section. */
extern AsmScn_t *asm_newsubscn (AsmScn_t *asmscn, unsigned int nr);
/* Return handle for new section group. The signature symbol can be
set later. */
extern AsmScnGrp_t *asm_newscngrp (AsmCtx_t *ctx, const char *grpname,
AsmSym_t *signature, Elf32_Word flags);
/* Set or overwrite signature symbol for group. */
extern int asm_scngrp_newsignature (AsmScnGrp_t *grp, AsmSym_t *signature);
/* Add zero terminated string STR of size LEN to (sub)section ASMSCN. */
extern int asm_addstrz (AsmScn_t *asmscn, const char *str, size_t len);
/* Add 8-bit signed integer NUM to (sub)section ASMSCN. */
extern int asm_addint8 (AsmScn_t *asmscn, int8_t num);
/* Add 8-bit unsigned integer NUM to (sub)section ASMSCN. */
extern int asm_adduint8 (AsmScn_t *asmscn, uint8_t num);
/* Add 16-bit signed integer NUM to (sub)section ASMSCN. */
extern int asm_addint16 (AsmScn_t *asmscn, int16_t num);
/* Add 16-bit unsigned integer NUM to (sub)section ASMSCN. */
extern int asm_adduint16 (AsmScn_t *asmscn, uint16_t num);
/* Add 32-bit signed integer NUM to (sub)section ASMSCN. */
extern int asm_addint32 (AsmScn_t *asmscn, int32_t num);
/* Add 32-bit unsigned integer NUM to (sub)section ASMSCN. */
extern int asm_adduint32 (AsmScn_t *asmscn, uint32_t num);
/* Add 64-bit signed integer NUM to (sub)section ASMSCN. */
extern int asm_addint64 (AsmScn_t *asmscn, int64_t num);
/* Add 64-bit unsigned integer NUM to (sub)section ASMSCN. */
extern int asm_adduint64 (AsmScn_t *asmscn, uint64_t num);
/* Add signed little endian base 128 integer NUM to (sub)section ASMSCN. */
extern int asm_addsleb128 (AsmScn_t *asmscn, int32_t num);
/* Add unsigned little endian base 128 integer NUM to (sub)section ASMSCN. */
extern int asm_adduleb128 (AsmScn_t *asmscn, uint32_t num);
/* Define new symbol NAME for current position in given section ASMSCN. */
extern AsmSym_t *asm_newsym (AsmScn_t *asmscn, const char *name,
GElf_Xword size, int type, int binding);
/* Define new common symbol NAME with given SIZE and alignment. */
extern AsmSym_t *asm_newcomsym (AsmCtx_t *ctx, const char *name,
GElf_Xword size, GElf_Addr align);
/* Define new common symbol NAME with given SIZE, VALUE, TYPE, and BINDING. */
extern AsmSym_t *asm_newabssym (AsmCtx_t *ctx, const char *name,
GElf_Xword size, GElf_Addr value,
int type, int binding);
/* Align (sub)section offset according to VALUE. */
extern int asm_align (AsmScn_t *asmscn, GElf_Word value);
/* Set the byte pattern used to fill gaps created by alignment. */
extern int asm_fill (AsmScn_t *asmscn, void *bytes, size_t len);
/* Return ELF descriptor created for the output file of the given context. */
extern Elf *asm_getelf (AsmCtx_t *ctx);
/* Return error code of last failing function call. This value is kept
separately for each thread. */
extern int asm_errno (void);
/* Return error string for ERROR. If ERROR is zero, return error string
for most recent error or NULL is none occurred. If ERROR is -1 the
behaviour is similar to the last case except that not NULL but a legal
string is returned. */
extern const char *asm_errmsg (int __error);
/* Create context descriptor for disassembler. */
extern DisasmCtx_t *disasm_begin (Ebl *ebl, Elf *elf, DisasmGetSymCB_t symcb);
/* Release descriptor for disassembler. */
extern int disasm_end (DisasmCtx_t *ctx);
/* Produce of disassembly output for given memory, store text in
provided buffer. */
extern int disasm_str (DisasmCtx_t *ctx, const uint8_t **startp,
const uint8_t *end, GElf_Addr addr, const char *fmt,
char **bufp, size_t len, void *symcbarg);
/* Produce disassembly output for given memory and output it using the
given callback functions. */
extern int disasm_cb (DisasmCtx_t *ctx, const uint8_t **startp,
const uint8_t *end, GElf_Addr addr, const char *fmt,
DisasmOutputCB_t outcb, void *outcbarg, void *symcbarg);
#ifdef __cplusplus
}
#endif
#endif /* libasm.h */
PK �zFZ�$[Tز ز libdw.hnu �[��� /* Interfaces for libdw.
Copyright (C) 2002-2010, 2013, 2014, 2016, 2018 Red Hat, Inc.
This file is part of elfutils.
This file is free software; you can redistribute it and/or modify
it under the terms of either
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at
your option) any later version
or
* the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at
your option) any later version
or both in parallel, as here.
elfutils 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 for more details.
You should have received copies of the GNU General Public License and
the GNU Lesser General Public License along with this program. If
not, see <http://www.gnu.org/licenses/>. */
#ifndef _LIBDW_H
#define _LIBDW_H 1
#include <gelf.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
/* Mode for the session. */
typedef enum
{
DWARF_C_READ, /* Read .. */
DWARF_C_RDWR, /* Read and write .. */
DWARF_C_WRITE, /* Write .. */
}
Dwarf_Cmd;
/* Callback results. */
enum
{
DWARF_CB_OK = 0,
DWARF_CB_ABORT
};
/* Error values. */
enum
{
DW_TAG_invalid = 0
#define DW_TAG_invalid DW_TAG_invalid
};
/* Type for offset in DWARF file. */
typedef GElf_Off Dwarf_Off;
/* Type for address in DWARF file. */
typedef GElf_Addr Dwarf_Addr;
/* Integer types. Big enough to hold any numeric value. */
typedef GElf_Xword Dwarf_Word;
typedef GElf_Sxword Dwarf_Sword;
/* For the times we know we do not need that much. */
typedef GElf_Half Dwarf_Half;
/* DWARF abbreviation record. */
typedef struct Dwarf_Abbrev Dwarf_Abbrev;
/* Returned to show the last DIE has be returned. */
#define DWARF_END_ABBREV ((Dwarf_Abbrev *) -1l)
/* Source code line information for CU. */
typedef struct Dwarf_Lines_s Dwarf_Lines;
/* One source code line information. */
typedef struct Dwarf_Line_s Dwarf_Line;
/* Source file information. */
typedef struct Dwarf_Files_s Dwarf_Files;
/* One address range record. */
typedef struct Dwarf_Arange_s Dwarf_Arange;
/* Address ranges of a file. */
typedef struct Dwarf_Aranges_s Dwarf_Aranges;
/* CU representation. */
struct Dwarf_CU;
typedef struct Dwarf_CU Dwarf_CU;
/* Macro information. */
typedef struct Dwarf_Macro_s Dwarf_Macro;
/* Attribute representation. */
typedef struct
{
unsigned int code;
unsigned int form;
unsigned char *valp;
struct Dwarf_CU *cu;
} Dwarf_Attribute;
/* Data block representation. */
typedef struct
{
Dwarf_Word length;
unsigned char *data;
} Dwarf_Block;
/* DIE information. */
typedef struct
{
/* The offset can be computed from the address. */
void *addr;
struct Dwarf_CU *cu;
Dwarf_Abbrev *abbrev;
// XXX We'll see what other information will be needed.
long int padding__;
} Dwarf_Die;
/* Returned to show the last DIE has be returned. */
#define DWARF_END_DIE ((Dwarf_Die *) -1l)
/* Global symbol information. */
typedef struct
{
Dwarf_Off cu_offset;
Dwarf_Off die_offset;
const char *name;
} Dwarf_Global;
/* One operation in a DWARF location expression.
A location expression is an array of these. */
typedef struct
{
uint8_t atom; /* Operation */
Dwarf_Word number; /* Operand */
Dwarf_Word number2; /* Possible second operand */
Dwarf_Word offset; /* Offset in location expression */
} Dwarf_Op;
/* This describes one Common Information Entry read from a CFI section.
Pointers here point into the DATA->d_buf block passed to dwarf_next_cfi. */
typedef struct
{
Dwarf_Off CIE_id; /* Always DW_CIE_ID_64 in Dwarf_CIE structures. */
/* Instruction stream describing initial state used by FDEs. If
we did not understand the whole augmentation string and it did
not use 'z', then there might be more augmentation data here
(and in FDEs) before the actual instructions. */
const uint8_t *initial_instructions;
const uint8_t *initial_instructions_end;
Dwarf_Word code_alignment_factor;
Dwarf_Sword data_alignment_factor;
Dwarf_Word return_address_register;
const char *augmentation; /* Augmentation string. */
/* Augmentation data, might be NULL. The size is correct only if
we understood the augmentation string sufficiently. */
const uint8_t *augmentation_data;
size_t augmentation_data_size;
size_t fde_augmentation_data_size;
} Dwarf_CIE;
/* This describes one Frame Description Entry read from a CFI section.
Pointers here point into the DATA->d_buf block passed to dwarf_next_cfi. */
typedef struct
{
/* Section offset of CIE this FDE refers to. This will never be
DW_CIE_ID_64 in an FDE. If this value is DW_CIE_ID_64, this is
actually a Dwarf_CIE structure. */
Dwarf_Off CIE_pointer;
/* We can't really decode anything further without looking up the CIE
and checking its augmentation string. Here follows the encoded
initial_location and address_range, then any augmentation data,
then the instruction stream. This FDE describes PC locations in
the byte range [initial_location, initial_location+address_range).
When the CIE augmentation string uses 'z', the augmentation data is
a DW_FORM_block (self-sized). Otherwise, when we understand the
augmentation string completely, fde_augmentation_data_size gives
the number of bytes of augmentation data before the instructions. */
const uint8_t *start;
const uint8_t *end;
} Dwarf_FDE;
/* Each entry in a CFI section is either a CIE described by Dwarf_CIE or
an FDE described by Dward_FDE. Check CIE_id to see which you have. */
typedef union
{
Dwarf_Off CIE_id; /* Always DW_CIE_ID_64 in Dwarf_CIE structures. */
Dwarf_CIE cie;
Dwarf_FDE fde;
} Dwarf_CFI_Entry;
/* Same as DW_CIE_ID_64 from dwarf.h to keep libdw.h independent. */
#define LIBDW_CIE_ID 0xffffffffffffffffULL
#define dwarf_cfi_cie_p(entry) ((entry)->cie.CIE_id == LIBDW_CIE_ID)
/* Opaque type representing a frame state described by CFI. */
typedef struct Dwarf_Frame_s Dwarf_Frame;
/* Opaque type representing a CFI section found in a DWARF or ELF file. */
typedef struct Dwarf_CFI_s Dwarf_CFI;
/* Handle for debug sessions. */
typedef struct Dwarf Dwarf;
/* Out-Of-Memory handler. */
typedef void (*__noreturn_attribute__ Dwarf_OOM) (void);
#ifdef __cplusplus
extern "C" {
#endif
/* Create a handle for a new debug session. */
extern Dwarf *dwarf_begin (int fildes, Dwarf_Cmd cmd);
/* Create a handle for a new debug session for an ELF file. */
extern Dwarf *dwarf_begin_elf (Elf *elf, Dwarf_Cmd cmd, Elf_Scn *scngrp);
/* Retrieve ELF descriptor used for DWARF access. */
extern Elf *dwarf_getelf (Dwarf *dwarf);
/* Retrieve DWARF descriptor used for a Dwarf_Die or Dwarf_Attribute.
A Dwarf_Die or a Dwarf_Attribute is associated with a particular
Dwarf_CU handle. This function returns the DWARF descriptor for
that Dwarf_CU. */
extern Dwarf *dwarf_cu_getdwarf (Dwarf_CU *cu);
/* Retrieves the DWARF descriptor for debugaltlink data. Returns NULL
if no alternate debug data has been supplied yet. libdw will try
to set the alt file on first use of an alt FORM if not yet explicitly
provided by dwarf_setalt. */
extern Dwarf *dwarf_getalt (Dwarf *main);
/* Provides the data referenced by the .gnu_debugaltlink section. The
caller should check that MAIN and ALT match (i.e., they have the
same build ID). It is the responsibility of the caller to ensure
that the data referenced by ALT stays valid while it is used by
MAIN, until dwarf_setalt is called on MAIN with a different
descriptor, or dwarf_end. Must be called before inspecting DIEs
that might have alt FORMs. Otherwise libdw will try to set the
alt file itself on first use. */
extern void dwarf_setalt (Dwarf *main, Dwarf *alt);
/* Release debugging handling context. */
extern int dwarf_end (Dwarf *dwarf);
/* Read the header for the DWARF CU. */
extern int dwarf_nextcu (Dwarf *dwarf, Dwarf_Off off, Dwarf_Off *next_off,
size_t *header_sizep, Dwarf_Off *abbrev_offsetp,
uint8_t *address_sizep, uint8_t *offset_sizep)
__nonnull_attribute__ (3);
/* Read the header of a DWARF CU or type unit. If TYPE_SIGNATUREP is not
null, this reads a type unit from the .debug_types section; otherwise
this reads a CU from the .debug_info section. */
extern int dwarf_next_unit (Dwarf *dwarf, Dwarf_Off off, Dwarf_Off *next_off,
size_t *header_sizep, Dwarf_Half *versionp,
Dwarf_Off *abbrev_offsetp,
uint8_t *address_sizep, uint8_t *offset_sizep,
uint64_t *type_signaturep, Dwarf_Off *type_offsetp)
__nonnull_attribute__ (3);
/* Gets the next Dwarf_CU (unit), version, unit type and if available
the CU DIE and sub (type) DIE of the unit. Returns 0 on success,
-1 on error or 1 if there are no more units. To start iterating
provide NULL for CU. If version < 5 the unit type is set from the
CU DIE if available (DW_UT_compile for DW_TAG_compile_unit,
DW_UT_type for DW_TAG_type_unit or DW_UT_partial for
DW_TAG_partial_unit), otherwise it is set to zero. If unavailable
(the version or unit type is unknown) the CU DIE is cleared.
Likewise if the sub DIE isn't isn't available (the unit type is not
DW_UT_type or DW_UT_split_type) the sub DIE tag is cleared. */
extern int dwarf_get_units (Dwarf *dwarf, Dwarf_CU *cu, Dwarf_CU **next_cu,
Dwarf_Half *version, uint8_t *unit_type,
Dwarf_Die *cudie, Dwarf_Die *subdie)
__nonnull_attribute__ (3);
/* Provides information and DIEs associated with the given Dwarf_CU
unit. Returns -1 on error, zero on success. Arguments not needed
may be NULL. If they are NULL and aren't known yet, they won't be
looked up. If the subdie doesn't exist for this unit_type it will
be cleared. If there is no unit_id for this unit type it will be
set to zero. */
extern int dwarf_cu_info (Dwarf_CU *cu,
Dwarf_Half *version, uint8_t *unit_type,
Dwarf_Die *cudie, Dwarf_Die *subdie,
uint64_t *unit_id,
uint8_t *address_size, uint8_t *offset_size);
/* Decode one DWARF CFI entry (CIE or FDE) from the raw section data.
The E_IDENT from the originating ELF file indicates the address
size and byte order used in the CFI section contained in DATA;
EH_FRAME_P should be true for .eh_frame format and false for
.debug_frame format. OFFSET is the byte position in the section
to start at; on return *NEXT_OFFSET is filled in with the byte
position immediately after this entry.
On success, returns 0 and fills in *ENTRY; use dwarf_cfi_cie_p to
see whether ENTRY->cie or ENTRY->fde is valid.
On errors, returns -1. Some format errors will permit safely
skipping to the next CFI entry though the current one is unusable.
In that case, *NEXT_OFF will be updated before a -1 return.
If there are no more CFI entries left in the section,
returns 1 and sets *NEXT_OFFSET to (Dwarf_Off) -1. */
extern int dwarf_next_cfi (const unsigned char e_ident[],
Elf_Data *data, bool eh_frame_p,
Dwarf_Off offset, Dwarf_Off *next_offset,
Dwarf_CFI_Entry *entry)
__nonnull_attribute__ (1, 2, 5, 6);
/* Use the CFI in the DWARF .debug_frame section.
Returns NULL if there is no such section (not an error).
The pointer returned can be used until dwarf_end is called on DWARF,
and must not be passed to dwarf_cfi_end.
Calling this more than once returns the same pointer. */
extern Dwarf_CFI *dwarf_getcfi (Dwarf *dwarf);
/* Use the CFI in the ELF file's exception-handling data.
Returns NULL if there is no such data.
The pointer returned can be used until elf_end is called on ELF,
and must be passed to dwarf_cfi_end before then.
Calling this more than once allocates independent data structures. */
extern Dwarf_CFI *dwarf_getcfi_elf (Elf *elf);
/* Release resources allocated by dwarf_getcfi_elf. */
extern int dwarf_cfi_end (Dwarf_CFI *cache);
/* Return DIE at given offset in .debug_info section. */
extern Dwarf_Die *dwarf_offdie (Dwarf *dbg, Dwarf_Off offset,
Dwarf_Die *result) __nonnull_attribute__ (3);
/* Return DIE at given offset in .debug_types section. */
extern Dwarf_Die *dwarf_offdie_types (Dwarf *dbg, Dwarf_Off offset,
Dwarf_Die *result)
__nonnull_attribute__ (3);
/* Return offset of DIE. */
extern Dwarf_Off dwarf_dieoffset (Dwarf_Die *die);
/* Return offset of DIE in CU. */
extern Dwarf_Off dwarf_cuoffset (Dwarf_Die *die);
/* Return CU DIE containing given DIE. */
extern Dwarf_Die *dwarf_diecu (Dwarf_Die *die, Dwarf_Die *result,
uint8_t *address_sizep, uint8_t *offset_sizep)
__nonnull_attribute__ (2);
/* Given a Dwarf_Die addr returns a (reconstructed) Dwarf_Die, or NULL
if the given addr didn't come from a valid Dwarf_Die. In particular
it will make sure that the correct Dwarf_CU pointer is set for the
Dwarf_Die, the Dwarf_Abbrev pointer will not be set up yet (it will
only be once the Dwarf_Die is used to read attributes, children or
siblings). This functions can be used to keep a reference to a
Dwarf_Die which you want to refer to later. The addr, and the result
of this function, is only valid while the associated Dwarf is valid. */
extern Dwarf_Die *dwarf_die_addr_die (Dwarf *dbg, void *addr,
Dwarf_Die *result)
__nonnull_attribute__ (3);
/* Return the CU DIE and the header info associated with a Dwarf_Die
or Dwarf_Attribute. A Dwarf_Die or a Dwarf_Attribute is associated
with a particular Dwarf_CU handle. This function returns the CU or
type unit DIE and header information for that Dwarf_CU. The
returned DIE is either a compile_unit, partial_unit or type_unit.
If it is a type_unit, then the type signature and type offset are
also provided, otherwise type_offset will be set to zero. See also
dwarf_diecu and dwarf_next_unit. */
extern Dwarf_Die *dwarf_cu_die (Dwarf_CU *cu, Dwarf_Die *result,
Dwarf_Half *versionp,
Dwarf_Off *abbrev_offsetp,
uint8_t *address_sizep,
uint8_t *offset_sizep,
uint64_t *type_signaturep,
Dwarf_Off *type_offsetp)
__nonnull_attribute__ (2);
/* Return CU DIE containing given address. */
extern Dwarf_Die *dwarf_addrdie (Dwarf *dbg, Dwarf_Addr addr,
Dwarf_Die *result) __nonnull_attribute__ (3);
/* Return child of current DIE. */
extern int dwarf_child (Dwarf_Die *die, Dwarf_Die *result)
__nonnull_attribute__ (2);
/* Locates the first sibling of DIE and places it in RESULT.
Returns 0 if a sibling was found, -1 if something went wrong.
Returns 1 if no sibling could be found and, if RESULT is not
the same as DIE, it sets RESULT->addr to the address of the
(non-sibling) DIE that follows this one, or NULL if this DIE
was the last one in the compilation unit. */
extern int dwarf_siblingof (Dwarf_Die *die, Dwarf_Die *result)
__nonnull_attribute__ (2);
/* For type aliases and qualifier type DIEs, which don't modify or
change the structural layout of the underlying type, follow the
DW_AT_type attribute (recursively) and return the underlying type
Dwarf_Die.
Returns 0 when RESULT contains a Dwarf_Die (possibly equal to the
given DIE) that isn't a type alias or qualifier type. Returns 1
when RESULT contains a type alias or qualifier Dwarf_Die that
couldn't be peeled further (it doesn't have a DW_TAG_type
attribute). Returns -1 when an error occurred.
The current DWARF specification defines one type alias tag
(DW_TAG_typedef) and seven modifier/qualifier type tags
(DW_TAG_const_type, DW_TAG_volatile_type, DW_TAG_restrict_type,
DW_TAG_atomic_type, DW_TAG_immutable_type, DW_TAG_packed_type and
DW_TAG_shared_type). This function won't peel modifier type
tags that change the way the underlying type is accessed such
as the pointer or reference type tags (DW_TAG_pointer_type,
DW_TAG_reference_type or DW_TAG_rvalue_reference_type).
A future version of this function might peel other alias or
qualifier type tags if a future DWARF version or GNU extension
defines other type aliases or qualifier type tags that don't modify,
change the structural layout or the way to access the underlying type. */
extern int dwarf_peel_type (Dwarf_Die *die, Dwarf_Die *result)
__nonnull_attribute__ (2);
/* Check whether the DIE has children. */
extern int dwarf_haschildren (Dwarf_Die *die) __nonnull_attribute__ (1);
/* Walks the attributes of DIE, starting at the one OFFSET bytes in,
calling the CALLBACK function for each one. Stops if the callback
function ever returns a value other than DWARF_CB_OK and returns the
offset of the offending attribute. If the end of the attributes
is reached 1 is returned. If something goes wrong -1 is returned and
the dwarf error number is set. */
extern ptrdiff_t dwarf_getattrs (Dwarf_Die *die,
int (*callback) (Dwarf_Attribute *, void *),
void *arg, ptrdiff_t offset)
__nonnull_attribute__ (2);
/* Return tag of given DIE. */
extern int dwarf_tag (Dwarf_Die *die) __nonnull_attribute__ (1);
/* Return specific attribute of DIE. */
extern Dwarf_Attribute *dwarf_attr (Dwarf_Die *die, unsigned int search_name,
Dwarf_Attribute *result)
__nonnull_attribute__ (3);
/* Check whether given DIE has specific attribute. */
extern int dwarf_hasattr (Dwarf_Die *die, unsigned int search_name);
/* These are the same as dwarf_attr and dwarf_hasattr, respectively,
but they resolve an indirect attribute through
DW_AT_abstract_origin, DW_AT_specification or, if the DIE is a
top-level split CU, the skeleton DIE. Note that the attribute
might come from a DIE in a different CU (possibly from a different
Dwarf file). In that case all attribute information needs to be
resolved through the CU associated with the returned
Dwarf_Attribute. The dwarf_form functions already do this
automatically. */
extern Dwarf_Attribute *dwarf_attr_integrate (Dwarf_Die *die,
unsigned int search_name,
Dwarf_Attribute *result)
__nonnull_attribute__ (3);
extern int dwarf_hasattr_integrate (Dwarf_Die *die, unsigned int search_name);
/* Check whether given attribute has specific form. */
extern int dwarf_hasform (Dwarf_Attribute *attr, unsigned int search_form);
/* Return attribute code of given attribute. */
extern unsigned int dwarf_whatattr (Dwarf_Attribute *attr);
/* Return form code of given attribute. */
extern unsigned int dwarf_whatform (Dwarf_Attribute *attr);
/* Return string associated with given attribute. */
extern const char *dwarf_formstring (Dwarf_Attribute *attrp);
/* Return unsigned constant represented by attribute. */
extern int dwarf_formudata (Dwarf_Attribute *attr, Dwarf_Word *return_uval)
__nonnull_attribute__ (2);
/* Return signed constant represented by attribute. */
extern int dwarf_formsdata (Dwarf_Attribute *attr, Dwarf_Sword *return_uval)
__nonnull_attribute__ (2);
/* Return address represented by attribute. */
extern int dwarf_formaddr (Dwarf_Attribute *attr, Dwarf_Addr *return_addr)
__nonnull_attribute__ (2);
/* This function is deprecated. Always use dwarf_formref_die instead.
Return reference offset represented by attribute. */
extern int dwarf_formref (Dwarf_Attribute *attr, Dwarf_Off *return_offset)
__nonnull_attribute__ (2) __deprecated_attribute__;
/* Look up the DIE in a reference-form attribute. */
extern Dwarf_Die *dwarf_formref_die (Dwarf_Attribute *attr, Dwarf_Die *die_mem)
__nonnull_attribute__ (2);
/* Return block represented by attribute. */
extern int dwarf_formblock (Dwarf_Attribute *attr, Dwarf_Block *return_block)
__nonnull_attribute__ (2);
/* Return flag represented by attribute. */
extern int dwarf_formflag (Dwarf_Attribute *attr, bool *return_bool)
__nonnull_attribute__ (2);
/* Simplified attribute value access functions. */
/* Return string in name attribute of DIE. */
extern const char *dwarf_diename (Dwarf_Die *die);
/* Return high PC attribute of DIE. */
extern int dwarf_highpc (Dwarf_Die *die, Dwarf_Addr *return_addr)
__nonnull_attribute__ (2);
/* Return low PC attribute of DIE. */
extern int dwarf_lowpc (Dwarf_Die *die, Dwarf_Addr *return_addr)
__nonnull_attribute__ (2);
/* Return entry_pc or low_pc attribute of DIE. */
extern int dwarf_entrypc (Dwarf_Die *die, Dwarf_Addr *return_addr)
__nonnull_attribute__ (2);
/* Return 1 if DIE's lowpc/highpc or ranges attributes match the PC address,
0 if not, or -1 for errors. */
extern int dwarf_haspc (Dwarf_Die *die, Dwarf_Addr pc);
/* Enumerate the PC address ranges covered by this DIE, covering all
addresses where dwarf_haspc returns true. In the first call OFFSET
should be zero and *BASEP need not be initialized. Returns -1 for
errors, zero when there are no more address ranges to report, or a
nonzero OFFSET value to pass to the next call. Each subsequent call
must preserve *BASEP from the prior call. Successful calls fill in
*STARTP and *ENDP with a contiguous address range. */
extern ptrdiff_t dwarf_ranges (Dwarf_Die *die,
ptrdiff_t offset, Dwarf_Addr *basep,
Dwarf_Addr *startp, Dwarf_Addr *endp);
/* Return byte size attribute of DIE. */
extern int dwarf_bytesize (Dwarf_Die *die);
/* Return bit size attribute of DIE. */
extern int dwarf_bitsize (Dwarf_Die *die);
/* Return bit offset attribute of DIE. */
extern int dwarf_bitoffset (Dwarf_Die *die);
/* Return array order attribute of DIE. */
extern int dwarf_arrayorder (Dwarf_Die *die);
/* Return source language attribute of DIE. */
extern int dwarf_srclang (Dwarf_Die *die);
/* Get abbreviation at given offset for given DIE. */
extern Dwarf_Abbrev *dwarf_getabbrev (Dwarf_Die *die, Dwarf_Off offset,
size_t *lengthp);
/* Get abbreviation at given offset in .debug_abbrev section. */
extern int dwarf_offabbrev (Dwarf *dbg, Dwarf_Off offset, size_t *lengthp,
Dwarf_Abbrev *abbrevp)
__nonnull_attribute__ (4);
/* Get abbreviation code. */
extern unsigned int dwarf_getabbrevcode (Dwarf_Abbrev *abbrev);
/* Get abbreviation tag. */
extern unsigned int dwarf_getabbrevtag (Dwarf_Abbrev *abbrev);
/* Return true if abbreviation is children flag set. */
extern int dwarf_abbrevhaschildren (Dwarf_Abbrev *abbrev);
/* Get number of attributes of abbreviation. */
extern int dwarf_getattrcnt (Dwarf_Abbrev *abbrev, size_t *attrcntp)
__nonnull_attribute__ (2);
/* Get specific attribute of abbreviation. */
extern int dwarf_getabbrevattr (Dwarf_Abbrev *abbrev, size_t idx,
unsigned int *namep, unsigned int *formp,
Dwarf_Off *offset);
/* Get specific attribute of abbreviation and any data encoded with it.
Specifically for DW_FORM_implicit_const data will be set to the
constant value associated. */
extern int dwarf_getabbrevattr_data (Dwarf_Abbrev *abbrev, size_t idx,
unsigned int *namep, unsigned int *formp,
Dwarf_Sword *datap, Dwarf_Off *offset);
/* Get string from-debug_str section. */
extern const char *dwarf_getstring (Dwarf *dbg, Dwarf_Off offset,
size_t *lenp);
/* Get public symbol information. */
extern ptrdiff_t dwarf_getpubnames (Dwarf *dbg,
int (*callback) (Dwarf *, Dwarf_Global *,
void *),
void *arg, ptrdiff_t offset)
__nonnull_attribute__ (2);
/* Get source file information for CU. */
extern int dwarf_getsrclines (Dwarf_Die *cudie, Dwarf_Lines **lines,
size_t *nlines) __nonnull_attribute__ (2, 3);
/* Return one of the source lines of the CU. */
extern Dwarf_Line *dwarf_onesrcline (Dwarf_Lines *lines, size_t idx);
/* Get the file source files used in the CU. */
extern int dwarf_getsrcfiles (Dwarf_Die *cudie, Dwarf_Files **files,
size_t *nfiles)
__nonnull_attribute__ (2);
/* Get source for address in CU. */
extern Dwarf_Line *dwarf_getsrc_die (Dwarf_Die *cudie, Dwarf_Addr addr);
/* Get source for file and line number. */
extern int dwarf_getsrc_file (Dwarf *dbg, const char *fname, int line, int col,
Dwarf_Line ***srcsp, size_t *nsrcs)
__nonnull_attribute__ (2, 5, 6);
/* Return line address. */
extern int dwarf_lineaddr (Dwarf_Line *line, Dwarf_Addr *addrp);
/* Return line VLIW operation index. */
extern int dwarf_lineop_index (Dwarf_Line *line, unsigned int *op_indexp);
/* Return line number. */
extern int dwarf_lineno (Dwarf_Line *line, int *linep)
__nonnull_attribute__ (2);
/* Return column in line. */
extern int dwarf_linecol (Dwarf_Line *line, int *colp)
__nonnull_attribute__ (2);
/* Return true if record is for beginning of a statement. */
extern int dwarf_linebeginstatement (Dwarf_Line *line, bool *flagp)
__nonnull_attribute__ (2);
/* Return true if record is for end of sequence. */
extern int dwarf_lineendsequence (Dwarf_Line *line, bool *flagp)
__nonnull_attribute__ (2);
/* Return true if record is for beginning of a basic block. */
extern int dwarf_lineblock (Dwarf_Line *line, bool *flagp)
__nonnull_attribute__ (2);
/* Return true if record is for end of prologue. */
extern int dwarf_lineprologueend (Dwarf_Line *line, bool *flagp)
__nonnull_attribute__ (2);
/* Return true if record is for beginning of epilogue. */
extern int dwarf_lineepiloguebegin (Dwarf_Line *line, bool *flagp)
__nonnull_attribute__ (2);
/* Return instruction-set architecture in this record. */
extern int dwarf_lineisa (Dwarf_Line *line, unsigned int *isap)
__nonnull_attribute__ (2);
/* Return code path discriminator in this record. */
extern int dwarf_linediscriminator (Dwarf_Line *line, unsigned int *discp)
__nonnull_attribute__ (2);
/* Find line information for address. The returned string is NULL when
an error occurred, or the file path. The file path is either absolute
or relative to the compilation directory. See dwarf_decl_file. */
extern const char *dwarf_linesrc (Dwarf_Line *line,
Dwarf_Word *mtime, Dwarf_Word *length);
/* Return the caller of this line if inlined. If not inlined,
return NULL. */
extern Dwarf_Line *dwarf_linecontext (Dwarf_Lines *lines, Dwarf_Line *line);
/* Return the function name in this line record. If this line is
inlined, this is the name of the function that was inlined. If this line
is not inlined, return NULL. */
extern const char *dwarf_linefunctionname (Dwarf *dbg, Dwarf_Line *line);
/* Return file information. The returned string is NULL when
an error occurred, or the file path. The file path is either absolute
or relative to the compilation directory. See dwarf_decl_file. */
extern const char *dwarf_filesrc (Dwarf_Files *file, size_t idx,
Dwarf_Word *mtime, Dwarf_Word *length);
/* Return the Dwarf_Files and index associated with the given Dwarf_Line. */
extern int dwarf_line_file (Dwarf_Line *line,
Dwarf_Files **files, size_t *idx)
__nonnull_attribute__ (2, 3);
/* Return the directory list used in the file information extracted.
(*RESULT)[0] is the CU's DW_AT_comp_dir value, and may be null.
(*RESULT)[0..*NDIRS-1] are the compile-time include directory path
encoded by the compiler. */
extern int dwarf_getsrcdirs (Dwarf_Files *files,
const char *const **result, size_t *ndirs)
__nonnull_attribute__ (2, 3);
/* Iterates through the debug line units. Returns 0 on success, -1 on
error or 1 if there are no more units. To start iterating use zero
for OFF and set *CU to NULL. On success NEXT_OFF will be set to
the next offset to use. The *CU will be set if this line table
needed a specific CU and needs to be given when calling
dwarf_next_lines again (to help dwarf_next_lines quickly find the
next CU). *CU might be set to NULL when it couldn't be found (the
compilation directory entry will be the empty string in that case)
or for DWARF 5 or later tables, which are self contained. SRCFILES
and SRCLINES may be NULL if the caller is not interested in the
actual line or file table. On success and when not NULL, NFILES
and NLINES will be set to the number of files in the file table and
number of lines in the line table. */
extern int dwarf_next_lines (Dwarf *dwarf, Dwarf_Off off,
Dwarf_Off *next_off, Dwarf_CU **cu,
Dwarf_Files **srcfiles, size_t *nfiles,
Dwarf_Lines **srclines, size_t *nlines)
__nonnull_attribute__ (3,4);
/* Return location expression, decoded as a list of operations. */
extern int dwarf_getlocation (Dwarf_Attribute *attr, Dwarf_Op **expr,
size_t *exprlen) __nonnull_attribute__ (2, 3);
/* Return location expressions. If the attribute uses a location list,
ADDRESS selects the relevant location expressions from the list.
There can be multiple matches, resulting in multiple expressions to
return. EXPRS and EXPRLENS are parallel arrays of NLOCS slots to
fill in. Returns the number of locations filled in, or -1 for
errors. If EXPRS is a null pointer, stores nothing and returns the
total number of locations. A return value of zero means that the
location list indicated no value is accessible. */
extern int dwarf_getlocation_addr (Dwarf_Attribute *attr, Dwarf_Addr address,
Dwarf_Op **exprs, size_t *exprlens,
size_t nlocs);
/* Enumerate the locations ranges and descriptions covered by the
given attribute. In the first call OFFSET should be zero and
*BASEP need not be initialized. Returns -1 for errors, zero when
there are no more locations to report, or a nonzero OFFSET
value to pass to the next call. Each subsequent call must preserve
*BASEP from the prior call. Successful calls fill in *STARTP and
*ENDP with a contiguous address range and *EXPR with a pointer to
an array of operations with length *EXPRLEN. If the attribute
describes a single location description and not a location list the
first call (with OFFSET zero) will return the location description
in *EXPR with *STARTP set to zero and *ENDP set to minus one. */
extern ptrdiff_t dwarf_getlocations (Dwarf_Attribute *attr,
ptrdiff_t offset, Dwarf_Addr *basep,
Dwarf_Addr *startp, Dwarf_Addr *endp,
Dwarf_Op **expr, size_t *exprlen);
/* Return the block associated with a DW_OP_implicit_value operation.
The OP pointer must point into an expression that dwarf_getlocation
or dwarf_getlocation_addr has returned given the same ATTR. */
extern int dwarf_getlocation_implicit_value (Dwarf_Attribute *attr,
const Dwarf_Op *op,
Dwarf_Block *return_block)
__nonnull_attribute__ (2, 3);
/* Return the attribute indicated by a DW_OP_GNU_implicit_pointer operation.
The OP pointer must point into an expression that dwarf_getlocation
or dwarf_getlocation_addr has returned given the same ATTR.
The result is the DW_AT_location or DW_AT_const_value attribute
of the OP->number DIE. */
extern int dwarf_getlocation_implicit_pointer (Dwarf_Attribute *attr,
const Dwarf_Op *op,
Dwarf_Attribute *result)
__nonnull_attribute__ (2, 3);
/* Return the DIE associated with an operation such as
DW_OP_GNU_implicit_pointer, DW_OP_GNU_parameter_ref, DW_OP_GNU_convert,
DW_OP_GNU_reinterpret, DW_OP_GNU_const_type, DW_OP_GNU_regval_type or
DW_OP_GNU_deref_type. The OP pointer must point into an expression that
dwarf_getlocation or dwarf_getlocation_addr has returned given the same
ATTR. The RESULT is a DIE that expresses a type or value needed by the
given OP. */
extern int dwarf_getlocation_die (Dwarf_Attribute *attr,
const Dwarf_Op *op,
Dwarf_Die *result)
__nonnull_attribute__ (2, 3);
/* Return the attribute expressing a value associated with an operation such
as DW_OP_implicit_value, DW_OP_GNU_entry_value or DW_OP_GNU_const_type.
The OP pointer must point into an expression that dwarf_getlocation
or dwarf_getlocation_addr has returned given the same ATTR.
The RESULT is a value expressed by an attribute such as DW_AT_location
or DW_AT_const_value. */
extern int dwarf_getlocation_attr (Dwarf_Attribute *attr,
const Dwarf_Op *op,
Dwarf_Attribute *result)
__nonnull_attribute__ (2, 3);
/* Compute the byte-size of a type DIE according to DWARF rules.
For most types, this is just DW_AT_byte_size.
For DW_TAG_array_type it can apply much more complex rules. */
extern int dwarf_aggregate_size (Dwarf_Die *die, Dwarf_Word *size);
/* Given a language code, as returned by dwarf_srclan, get the default
lower bound for a subrange type without a lower bound attribute.
Returns zero on success or -1 on failure when the given language
wasn't recognized. */
extern int dwarf_default_lower_bound (int lang, Dwarf_Sword *result)
__nonnull_attribute__ (2);
/* Return scope DIEs containing PC address.
Sets *SCOPES to a malloc'd array of Dwarf_Die structures,
and returns the number of elements in the array.
(*SCOPES)[0] is the DIE for the innermost scope containing PC,
(*SCOPES)[1] is the DIE for the scope containing that scope, and so on.
Returns -1 for errors or 0 if no scopes match PC. */
extern int dwarf_getscopes (Dwarf_Die *cudie, Dwarf_Addr pc,
Dwarf_Die **scopes);
/* Return scope DIEs containing the given DIE.
Sets *SCOPES to a malloc'd array of Dwarf_Die structures,
and returns the number of elements in the array.
(*SCOPES)[0] is a copy of DIE.
(*SCOPES)[1] is the DIE for the scope containing that scope, and so on.
Returns -1 for errors or 0 if DIE is not found in any scope entry. */
extern int dwarf_getscopes_die (Dwarf_Die *die, Dwarf_Die **scopes);
/* Search SCOPES[0..NSCOPES-1] for a variable called NAME.
Ignore the first SKIP_SHADOWS scopes that match the name.
If MATCH_FILE is not null, accept only declaration in that source file;
if MATCH_LINENO or MATCH_LINECOL are also nonzero, accept only declaration
at that line and column.
If successful, fill in *RESULT with the DIE of the variable found,
and return N where SCOPES[N] is the scope defining the variable.
Return -1 for errors or -2 for no matching variable found. */
extern int dwarf_getscopevar (Dwarf_Die *scopes, int nscopes,
const char *name, int skip_shadows,
const char *match_file,
int match_lineno, int match_linecol,
Dwarf_Die *result);
/* Return list address ranges. */
extern int dwarf_getaranges (Dwarf *dbg, Dwarf_Aranges **aranges,
size_t *naranges)
__nonnull_attribute__ (2);
/* Return one of the address range entries. */
extern Dwarf_Arange *dwarf_onearange (Dwarf_Aranges *aranges, size_t idx);
/* Return information in address range record. */
extern int dwarf_getarangeinfo (Dwarf_Arange *arange, Dwarf_Addr *addrp,
Dwarf_Word *lengthp, Dwarf_Off *offsetp);
/* Get address range which includes given address. */
extern Dwarf_Arange *dwarf_getarange_addr (Dwarf_Aranges *aranges,
Dwarf_Addr addr);
/* Get functions in CUDIE. The given callback will be called for all
defining DW_TAG_subprograms in the CU DIE tree. If the callback
returns DWARF_CB_ABORT the return value can be used as offset argument
to resume the function to find all remaining functions (this is not
really recommended, since it needs to rewalk the CU DIE tree first till
that offset is found again). If the callback returns DWARF_CB_OK
dwarf_getfuncs will not return but keep calling the callback for each
function DIE it finds. Pass zero for offset on the first call to walk
the full CU DIE tree. If no more functions can be found and the callback
returned DWARF_CB_OK then the function returns zero. */
extern ptrdiff_t dwarf_getfuncs (Dwarf_Die *cudie,
int (*callback) (Dwarf_Die *, void *),
void *arg, ptrdiff_t offset);
/* Return file name containing definition of the given declaration.
Of the DECL has an (indirect, see dwarf_attr_integrate) decl_file
attribute. The returned file path is either absolute, or relative
to the compilation directory. Given the decl DIE, the compilation
directory can be retrieved through:
dwarf_formstring (dwarf_attr (dwarf_diecu (decl, &cudie, NULL, NULL),
DW_AT_comp_dir, &attr));
Returns NULL if no decl_file could be found or an error occurred. */
extern const char *dwarf_decl_file (Dwarf_Die *decl);
/* Get line number of beginning of given declaration. */
extern int dwarf_decl_line (Dwarf_Die *decl, int *linep)
__nonnull_attribute__ (2);
/* Get column number of beginning of given declaration. */
extern int dwarf_decl_column (Dwarf_Die *decl, int *colp)
__nonnull_attribute__ (2);
/* Return nonzero if given function is an abstract inline definition. */
extern int dwarf_func_inline (Dwarf_Die *func);
/* Find each concrete inlined instance of the abstract inline definition. */
extern int dwarf_func_inline_instances (Dwarf_Die *func,
int (*callback) (Dwarf_Die *, void *),
void *arg);
/* Find the appropriate PC location or locations for function entry
breakpoints for the given DW_TAG_subprogram DIE. Returns -1 for errors.
On success, returns the number of breakpoint locations (never zero)
and sets *BKPTS to a malloc'd vector of addresses. */
extern int dwarf_entry_breakpoints (Dwarf_Die *die, Dwarf_Addr **bkpts);
/* Iterate through the macro unit referenced by CUDIE and call
CALLBACK for each macro information entry. To start the iteration,
one would pass DWARF_GETMACROS_START for TOKEN.
The iteration continues while CALLBACK returns DWARF_CB_OK. If the
callback returns DWARF_CB_ABORT, the iteration stops and a
continuation token is returned, which can be used to restart the
iteration at the point where it ended. Returns -1 for errors or 0
if there are no more macro entries.
Note that the Dwarf_Macro pointer passed to the callback is only
valid for the duration of the callback invocation.
For backward compatibility, a token of 0 is accepted for starting
the iteration as well, but in that case this interface will refuse
to serve opcode 0xff from .debug_macro sections. Such opcode would
be considered invalid and would cause dwarf_getmacros to return
with error. */
#define DWARF_GETMACROS_START PTRDIFF_MIN
extern ptrdiff_t dwarf_getmacros (Dwarf_Die *cudie,
int (*callback) (Dwarf_Macro *, void *),
void *arg, ptrdiff_t token)
__nonnull_attribute__ (2);
/* This is similar in operation to dwarf_getmacros, but selects the
unit to iterate through by offset instead of by CU, and always
iterates .debug_macro. This can be used for handling
DW_MACRO_GNU_transparent_include's or similar opcodes.
TOKEN value of DWARF_GETMACROS_START can be used to start the
iteration.
It is not appropriate to obtain macro unit offset by hand from a CU
DIE and then request iteration through this interface. The reason
for this is that if a dwarf_macro_getsrcfiles is later called,
there would be no way to figure out what DW_AT_comp_dir was present
on the CU DIE, and file names referenced in either the macro unit
itself, or the .debug_line unit that it references, might be wrong.
Use dwarf_getmacros. */
extern ptrdiff_t dwarf_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
int (*callback) (Dwarf_Macro *, void *),
void *arg, ptrdiff_t token)
__nonnull_attribute__ (3);
/* Get the source files used by the macro entry. You shouldn't assume
that Dwarf_Files references will remain valid after MACRO becomes
invalid. (Which is to say it's only valid within the
dwarf_getmacros* callback.) Returns 0 for success or a negative
value in case of an error. */
extern int dwarf_macro_getsrcfiles (Dwarf *dbg, Dwarf_Macro *macro,
Dwarf_Files **files, size_t *nfiles)
__nonnull_attribute__ (2, 3, 4);
/* Return macro opcode. That's a constant that can be either from
DW_MACINFO_* domain or DW_MACRO_GNU_* domain. The two domains have
compatible values, so it's OK to use either of them for
comparisons. The only differences is 0xff, which could be either
DW_MACINFO_vendor_ext or a vendor-defined DW_MACRO_* constant. One
would need to look if the CU DIE which the iteration was requested
for has attribute DW_AT_macro_info, or either of DW_AT_GNU_macros
or DW_AT_macros to differentiate the two interpretations. */
extern int dwarf_macro_opcode (Dwarf_Macro *macro, unsigned int *opcodep)
__nonnull_attribute__ (2);
/* Get number of parameters of MACRO and store it to *PARAMCNTP. */
extern int dwarf_macro_getparamcnt (Dwarf_Macro *macro, size_t *paramcntp);
/* Get IDX-th parameter of MACRO (numbered from zero), and stores it
to *ATTRIBUTE. Returns 0 on success or -1 for errors.
After a successful call, you can query ATTRIBUTE by dwarf_whatform
to determine which of the dwarf_formX calls to make to get actual
value out of ATTRIBUTE. Note that calling dwarf_whatattr is not
meaningful for pseudo-attributes formed this way. */
extern int dwarf_macro_param (Dwarf_Macro *macro, size_t idx,
Dwarf_Attribute *attribute);
/* Return macro parameter with index 0. This will return -1 if the
parameter is not an integral value. Use dwarf_macro_param for more
general access. */
extern int dwarf_macro_param1 (Dwarf_Macro *macro, Dwarf_Word *paramp)
__nonnull_attribute__ (2);
/* Return macro parameter with index 1. This will return -1 if the
parameter is not an integral or string value. Use
dwarf_macro_param for more general access. */
extern int dwarf_macro_param2 (Dwarf_Macro *macro, Dwarf_Word *paramp,
const char **strp);
/* Compute what's known about a call frame when the PC is at ADDRESS.
Returns 0 for success or -1 for errors.
On success, *FRAME is a malloc'd pointer. */
extern int dwarf_cfi_addrframe (Dwarf_CFI *cache,
Dwarf_Addr address, Dwarf_Frame **frame)
__nonnull_attribute__ (3);
/* Return the DWARF register number used in FRAME to denote
the return address in FRAME's caller frame. The remaining
arguments can be non-null to fill in more information.
Fill [*START, *END) with the PC range to which FRAME's information applies.
Fill in *SIGNALP to indicate whether this is a signal-handling frame.
If true, this is the implicit call frame that calls a signal handler.
This frame's "caller" is actually the interrupted state, not a call;
its return address is an exact PC, not a PC after a call instruction. */
extern int dwarf_frame_info (Dwarf_Frame *frame,
Dwarf_Addr *start, Dwarf_Addr *end, bool *signalp);
/* Return a DWARF expression that yields the Canonical Frame Address at
this frame state. Returns -1 for errors, or zero for success, with
*NOPS set to the number of operations stored at *OPS. That pointer
can be used only as long as FRAME is alive and unchanged. *NOPS is
zero if the CFA cannot be determined here. Note that if nonempty,
*OPS is a DWARF expression, not a location description--append
DW_OP_stack_value to a get a location description for the CFA. */
extern int dwarf_frame_cfa (Dwarf_Frame *frame, Dwarf_Op **ops, size_t *nops)
__nonnull_attribute__ (2);
/* Deliver a DWARF location description that yields the location or
value of DWARF register number REGNO in the state described by FRAME.
Returns -1 for errors or zero for success, setting *NOPS to the
number of operations in the array stored at *OPS. Note the last
operation is DW_OP_stack_value if there is no mutable location but
only a computable value.
*NOPS zero with *OPS set to OPS_MEM means CFI says the caller's
REGNO is "undefined", i.e. it's call-clobbered and cannot be recovered.
*NOPS zero with *OPS set to a null pointer means CFI says the
caller's REGNO is "same_value", i.e. this frame did not change it;
ask the caller frame where to find it.
For common simple expressions *OPS is OPS_MEM (which is a caller
owned array for at least 3 Dwarf_Ops). For arbitrary DWARF
expressions in the CFI, *OPS is an internal pointer that can be
used as long as the Dwarf_CFI used to create FRAME remains
alive. */
extern int dwarf_frame_register (Dwarf_Frame *frame, int regno,
Dwarf_Op ops_mem[3],
Dwarf_Op **ops, size_t *nops)
__nonnull_attribute__ (3, 4, 5);
/* Return error code of last failing function call. This value is kept
separately for each thread. */
extern int dwarf_errno (void);
/* Return error string for ERROR. If ERROR is zero, return error string
for most recent error or NULL is none occurred. If ERROR is -1 the
behaviour is similar to the last case except that not NULL but a legal
string is returned. */
extern const char *dwarf_errmsg (int err);
/* Register new Out-Of-Memory handler. The old handler is returned. */
extern Dwarf_OOM dwarf_new_oom_handler (Dwarf *dbg, Dwarf_OOM handler);
/* Inline optimizations. */
#ifdef __OPTIMIZE__
/* Return attribute code of given attribute. */
__libdw_extern_inline unsigned int
dwarf_whatattr (Dwarf_Attribute *attr)
{
return attr == NULL ? 0 : attr->code;
}
/* Return attribute code of given attribute. */
__libdw_extern_inline unsigned int
dwarf_whatform (Dwarf_Attribute *attr)
{
return attr == NULL ? 0 : attr->form;
}
#endif /* Optimize. */
#ifdef __cplusplus
}
#endif
#endif /* libdw.h */
PK �zFZ��i�ؖ ؖ libdwfl.hnu �[��� /* Interfaces for libdwfl.
Copyright (C) 2005-2010, 2013 Red Hat, Inc.
This file is part of elfutils.
This file is free software; you can redistribute it and/or modify
it under the terms of either
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at
your option) any later version
or
* the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at
your option) any later version
or both in parallel, as here.
elfutils 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 for more details.
You should have received copies of the GNU General Public License and
the GNU Lesser General Public License along with this program. If
not, see <http://www.gnu.org/licenses/>. */
#ifndef _LIBDWFL_H
#define _LIBDWFL_H 1
#include "libdw.h"
#include <stdio.h>
/* Handle for a session using the library. */
typedef struct Dwfl Dwfl;
/* Handle for a module. */
typedef struct Dwfl_Module Dwfl_Module;
/* Handle describing a line record. */
typedef struct Dwfl_Line Dwfl_Line;
/* This holds information common for all the frames of one backtrace for
a particular thread/task/TID. Several threads belong to one Dwfl. */
typedef struct Dwfl_Thread Dwfl_Thread;
/* This holds everything we know about the state of the frame at a particular
PC location described by an FDE belonging to Dwfl_Thread. */
typedef struct Dwfl_Frame Dwfl_Frame;
/* Handle for debuginfod-client connection. */
#ifndef _ELFUTILS_DEBUGINFOD_CLIENT_TYPEDEF
typedef struct debuginfod_client debuginfod_client;
#define _ELFUTILS_DEBUGINFOD_CLIENT_TYPEDEF 1
#endif
/* Callbacks. */
typedef struct
{
int (*find_elf) (Dwfl_Module *mod, void **userdata,
const char *modname, Dwarf_Addr base,
char **file_name, Elf **elfp);
int (*find_debuginfo) (Dwfl_Module *mod, void **userdata,
const char *modname, Dwarf_Addr base,
const char *file_name,
const char *debuglink_file, GElf_Word debuglink_crc,
char **debuginfo_file_name);
/* Fill *ADDR with the loaded address of the section called SECNAME in
the given module. Use (Dwarf_Addr) -1 if this section is omitted from
accessible memory. This is called exactly once for each SHF_ALLOC
section that relocations affecting DWARF data refer to, so it can
easily be used to collect state about the sections referenced. */
int (*section_address) (Dwfl_Module *mod, void **userdata,
const char *modname, Dwarf_Addr base,
const char *secname,
GElf_Word shndx, const GElf_Shdr *shdr,
Dwarf_Addr *addr);
char **debuginfo_path; /* See dwfl_standard_find_debuginfo. */
} Dwfl_Callbacks;
#ifdef __cplusplus
extern "C" {
#endif
/* Start a new session with the library. */
extern Dwfl *dwfl_begin (const Dwfl_Callbacks *callbacks)
__nonnull_attribute__ (1);
/* End a session. */
extern void dwfl_end (Dwfl *);
/* Return implementation's version string suitable for printing. */
extern const char *dwfl_version (Dwfl *);
/* Return error code of last failing function call. This value is kept
separately for each thread. */
extern int dwfl_errno (void);
/* Return error string for ERROR. If ERROR is zero, return error string
for most recent error or NULL if none occurred. If ERROR is -1 the
behaviour is similar to the last case except that not NULL but a legal
string is returned. */
extern const char *dwfl_errmsg (int err);
/* Start reporting the current set of segments and modules to the library.
All existing segments are wiped. Existing modules are marked to be
deleted, and will not be found via dwfl_addrmodule et al if they are not
re-reported before dwfl_report_end is called. */
extern void dwfl_report_begin (Dwfl *dwfl);
/* Report that segment NDX begins at PHDR->p_vaddr + BIAS.
If NDX is < 0, the value succeeding the last call's NDX
is used instead (zero on the first call). IDENT is ignored.
If nonzero, the smallest PHDR->p_align value seen sets the
effective page size for the address space DWFL describes.
This is the granularity at which reported module boundary
addresses will be considered to fall in or out of a segment.
Returns -1 for errors, or NDX (or its assigned replacement) on success.
Reporting segments at all is optional. Its only benefit to the caller is to
offer this quick lookup via dwfl_addrsegment, or use other segment-based
calls. */
extern int dwfl_report_segment (Dwfl *dwfl, int ndx,
const GElf_Phdr *phdr, GElf_Addr bias,
const void *ident);
/* Report that a module called NAME spans addresses [START, END).
Returns the module handle, either existing or newly allocated,
or returns a null pointer for an allocation error. */
extern Dwfl_Module *dwfl_report_module (Dwfl *dwfl, const char *name,
Dwarf_Addr start, Dwarf_Addr end);
/* Report a module to address BASE with start and end addresses computed
from the ELF program headers in the given file - see the table below.
FD may be -1 to open FILE_NAME. On success, FD is consumed by the
library, and the `find_elf' callback will not be used for this module.
ADD_P_VADDR BASE
ET_EXEC ignored ignored
ET_DYN false absolute address where to place the file
true start address relative to ELF's phdr p_vaddr
ET_REL ignored absolute address where to place the file
ET_CORE ignored ignored
ET_DYN ELF phdr p_vaddr address can be non-zero if the shared library
has been prelinked by tool prelink(8). */
extern Dwfl_Module *dwfl_report_elf (Dwfl *dwfl, const char *name,
const char *file_name, int fd,
GElf_Addr base, bool add_p_vaddr);
/* Similar, but report the module for offline use. All ET_EXEC files
being reported must be reported before any relocatable objects.
If this is used, dwfl_report_module and dwfl_report_elf may not be
used in the same reporting session. */
extern Dwfl_Module *dwfl_report_offline (Dwfl *dwfl, const char *name,
const char *file_name, int fd);
/* Similar, but report ELF from memory region. */
extern Dwfl_Module *dwfl_report_offline_memory (Dwfl *dwfl, const char *name,
const char *file_name,
char *data, size_t size);
/* Finish reporting the current set of modules to the library.
If REMOVED is not null, it's called for each module that
existed before but was not included in the current report.
Returns a nonzero return value from the callback.
The callback may call dwfl_report_module; doing so with the
details of the module being removed prevents its removal.
DWFL cannot be used until this function has returned zero. */
extern int dwfl_report_end (Dwfl *dwfl,
int (*removed) (Dwfl_Module *, void *,
const char *, Dwarf_Addr,
void *arg),
void *arg);
/* Start reporting additional modules to the library. No calls but
dwfl_report_* can be made on DWFL until dwfl_report_end is called.
This is like dwfl_report_begin, but all the old modules are kept on.
More dwfl_report_* calls can follow to add more modules.
When dwfl_report_end is called, no old modules will be removed. */
extern void dwfl_report_begin_add (Dwfl *dwfl);
/* Return the name of the module, and for each non-null argument store
interesting details: *USERDATA is a location for storing your own
pointer, **USERDATA is initially null; *START and *END give the address
range covered by the module; *DWBIAS is the address bias for debugging
information, and *SYMBIAS for symbol table entries (either is -1 if not
yet accessed); *MAINFILE is the name of the ELF file, and *DEBUGFILE the
name of the debuginfo file (might be equal to *MAINFILE; either is null
if not yet accessed). */
extern const char *dwfl_module_info (Dwfl_Module *mod, void ***userdata,
Dwarf_Addr *start, Dwarf_Addr *end,
Dwarf_Addr *dwbias, Dwarf_Addr *symbias,
const char **mainfile,
const char **debugfile);
/* Iterate through the modules, starting the walk with OFFSET == 0.
Calls *CALLBACK for each module as long as it returns DWARF_CB_OK.
When *CALLBACK returns another value, the walk stops and the
return value can be passed as OFFSET to resume it. Returns 0 when
there are no more modules, or -1 for errors. */
extern ptrdiff_t dwfl_getmodules (Dwfl *dwfl,
int (*callback) (Dwfl_Module *, void **,
const char *, Dwarf_Addr,
void *arg),
void *arg,
ptrdiff_t offset);
/* Find the module containing the given address. */
extern Dwfl_Module *dwfl_addrmodule (Dwfl *dwfl, Dwarf_Addr address);
/* Find the segment, if any, and module, if any, containing ADDRESS.
Returns a segment index returned by dwfl_report_segment, or -1
if no segment matches the address. Regardless of the return value,
*MOD is always set to the module containing ADDRESS, or to null. */
extern int dwfl_addrsegment (Dwfl *dwfl, Dwarf_Addr address, Dwfl_Module **mod);
/* Report the known build ID bits associated with a module.
If VADDR is nonzero, it gives the absolute address where those
bits are found within the module. This can be called at any
time, but is usually used immediately after dwfl_report_module.
Once the module's main ELF file is opened, the ID note found
there takes precedence and cannot be changed. */
extern int dwfl_module_report_build_id (Dwfl_Module *mod,
const unsigned char *bits, size_t len,
GElf_Addr vaddr)
__nonnull_attribute__ (2);
/* Extract the build ID bits associated with a module.
Returns -1 for errors, 0 if no ID is known, or the number of ID bytes.
When an ID is found, *BITS points to it; *VADDR is the absolute address
at which the ID bits are found within the module, or 0 if unknown.
This returns 0 when the module's main ELF file has not yet been loaded
and its build ID bits were not reported. To ensure the ID is always
returned when determinable, call dwfl_module_getelf first. */
extern int dwfl_module_build_id (Dwfl_Module *mod,
const unsigned char **bits, GElf_Addr *vaddr)
__nonnull_attribute__ (2, 3);
/*** Standard callbacks ***/
/* These standard find_elf and find_debuginfo callbacks are
controlled by a string specifying directories to look in.
If `debuginfo_path' is set in the Dwfl_Callbacks structure
and the char * it points to is not null, that supplies the
string. Otherwise a default path is used.
If the first character of the string is + or - that enables or
disables CRC32 checksum validation when it's necessary. The
remainder of the string is composed of elements separated by
colons. Each element can start with + or - to override the
global checksum behavior. This flag is never relevant when
working with build IDs, but it's always parsed in the path
string. The remainder of the element indicates a directory.
Searches by build ID consult only the elements naming absolute
directory paths. They look under those directories for a link
named ".build-id/xx/yy" or ".build-id/xx/yy.debug", where "xxyy"
is the lower-case hexadecimal representation of the ID bytes.
In searches for debuginfo by name, if the remainder of the
element is empty, the directory containing the main file is
tried; if it's an absolute path name, the absolute directory path
(and any subdirectory of that path) containing the main file is
taken as a subdirectory of this path; a relative path name is taken
as a subdirectory of the directory containing the main file.
Hence for /usr/bin/ls, the default string ":.debug:/usr/lib/debug"
says to look in /usr/bin, then /usr/bin/.debug, then the path subdirs
under /usr/lib/debug, in the order /usr/lib/debug/usr/bin, then
/usr/lib/debug/bin, and finally /usr/lib/debug, for the file name in
the .gnu_debuglink section (or "ls.debug" if none was found). */
/* Standard find_elf callback function working solely on build ID.
This can be tried first by any find_elf callback, to use the
bits passed to dwfl_module_report_build_id, if any. */
extern int dwfl_build_id_find_elf (Dwfl_Module *, void **,
const char *, Dwarf_Addr,
char **, Elf **);
/* Standard find_debuginfo callback function working solely on build ID.
This can be tried first by any find_debuginfo callback,
to use the build ID bits from the main file when present. */
extern int dwfl_build_id_find_debuginfo (Dwfl_Module *, void **,
const char *, Dwarf_Addr,
const char *, const char *,
GElf_Word, char **);
/* Standard find_debuginfo callback function.
If a build ID is available, this tries first to use that.
If there is no build ID or no valid debuginfo found by ID,
it searches the debuginfo path by name, as described above.
Any file found in the path is validated by build ID if possible,
or else by CRC32 checksum if enabled, and skipped if it does not match. */
extern int dwfl_standard_find_debuginfo (Dwfl_Module *, void **,
const char *, Dwarf_Addr,
const char *, const char *,
GElf_Word, char **);
/* This callback must be used when using dwfl_offline_* to report modules,
if ET_REL is to be supported. */
extern int dwfl_offline_section_address (Dwfl_Module *, void **,
const char *, Dwarf_Addr,
const char *, GElf_Word,
const GElf_Shdr *,
Dwarf_Addr *addr);
/* Callbacks for working with kernel modules in the running Linux kernel. */
extern int dwfl_linux_kernel_find_elf (Dwfl_Module *, void **,
const char *, Dwarf_Addr,
char **, Elf **);
extern int dwfl_linux_kernel_module_section_address (Dwfl_Module *, void **,
const char *, Dwarf_Addr,
const char *, GElf_Word,
const GElf_Shdr *,
Dwarf_Addr *addr);
/* Call dwfl_report_elf for the running Linux kernel.
Returns zero on success, -1 if dwfl_report_module failed,
or an errno code if opening the kernel binary failed. */
extern int dwfl_linux_kernel_report_kernel (Dwfl *dwfl);
/* Call dwfl_report_module for each kernel module in the running Linux kernel.
Returns zero on success, -1 if dwfl_report_module failed,
or an errno code if reading the list of modules failed. */
extern int dwfl_linux_kernel_report_modules (Dwfl *dwfl);
/* Report a kernel and its modules found on disk, for offline use.
If RELEASE starts with '/', it names a directory to look in;
if not, it names a directory to find under /lib/modules/;
if null, /lib/modules/`uname -r` is used.
Returns zero on success, -1 if dwfl_report_module failed,
or an errno code if finding the files on disk failed.
If PREDICATE is not null, it is called with each module to be reported;
its arguments are the module name, and the ELF file name or null if unknown,
and its return value should be zero to skip the module, one to report it,
or -1 to cause the call to fail and return errno. */
extern int dwfl_linux_kernel_report_offline (Dwfl *dwfl, const char *release,
int (*predicate) (const char *,
const char *));
/* Examine an ET_CORE file and report modules based on its contents.
This can follow a dwfl_report_offline call to bootstrap the
DT_DEBUG method of following the dynamic linker link_map chain, in
case the core file does not contain enough of the executable's text
segment to locate its PT_DYNAMIC in the dump. In such case you need to
supply non-NULL EXECUTABLE, otherwise dynamic libraries will not be loaded
into the DWFL map. This might call dwfl_report_elf on file names found in
the dump if reading some link_map files is the only way to ascertain those
modules' addresses. Returns the number of modules reported, or -1 for
errors. */
extern int dwfl_core_file_report (Dwfl *dwfl, Elf *elf, const char *executable);
/* Call dwfl_report_module for each file mapped into the address space of PID.
Returns zero on success, -1 if dwfl_report_module failed,
or an errno code if opening the proc files failed. */
extern int dwfl_linux_proc_report (Dwfl *dwfl, pid_t pid);
/* Similar, but reads an input stream in the format of Linux /proc/PID/maps
files giving module layout, not the file for a live process. */
extern int dwfl_linux_proc_maps_report (Dwfl *dwfl, FILE *);
/* Trivial find_elf callback for use with dwfl_linux_proc_report.
This uses the module name as a file name directly and tries to open it
if it begin with a slash, or handles the magic string "[vdso]". */
extern int dwfl_linux_proc_find_elf (Dwfl_Module *mod, void **userdata,
const char *module_name, Dwarf_Addr base,
char **file_name, Elf **);
/* Standard argument parsing for using a standard callback set. */
struct argp;
extern const struct argp *dwfl_standard_argp (void) __const_attribute__;
/*** Relocation of addresses from Dwfl ***/
/* Return the number of relocatable bases associated with the module,
which is zero for ET_EXEC and one for ET_DYN. Returns -1 for errors. */
extern int dwfl_module_relocations (Dwfl_Module *mod);
/* Return the relocation base index associated with the *ADDRESS location,
and adjust *ADDRESS to be an offset relative to that base.
Returns -1 for errors. */
extern int dwfl_module_relocate_address (Dwfl_Module *mod,
Dwarf_Addr *address);
/* Return the ELF section name for the given relocation base index;
if SHNDXP is not null, set *SHNDXP to the ELF section index.
For ET_DYN, returns "" and sets *SHNDXP to SHN_ABS; the relocation
base is the runtime start address reported for the module.
Returns null for errors. */
extern const char *dwfl_module_relocation_info (Dwfl_Module *mod,
unsigned int idx,
GElf_Word *shndxp);
/* Validate that ADDRESS and ADDRESS+OFFSET lie in a known module
and both within the same contiguous region for relocation purposes.
Returns zero for success and -1 for errors. */
extern int dwfl_validate_address (Dwfl *dwfl,
Dwarf_Addr address, Dwarf_Sword offset);
/*** ELF access functions ***/
/* Fetch the module main ELF file (where the allocated sections
are found) for use with libelf. If successful, fills in *BIAS
with the difference between addresses within the loaded module
and those in symbol tables or Dwarf information referring to it. */
extern Elf *dwfl_module_getelf (Dwfl_Module *, GElf_Addr *bias)
__nonnull_attribute__ (2);
/* Return the number of symbols in the module's symbol table,
or -1 for errors. */
extern int dwfl_module_getsymtab (Dwfl_Module *mod);
/* Return the index of the first global symbol in the module's symbol
table, or -1 for errors. In each symbol table, all symbols with
STB_LOCAL binding precede the weak and global symbols. This
function returns the symbol table index one greater than the last
local symbol. */
extern int dwfl_module_getsymtab_first_global (Dwfl_Module *mod);
/* Fetch one entry from the module's symbol table. On errors, returns
NULL. If successful, fills in *SYM and returns the string for st_name.
This works like gelf_getsym except that st_value is always adjusted to
an absolute value based on the module's location, when the symbol is in
an SHF_ALLOC section. If SHNDXP is non-null, it's set with the section
index (whether from st_shndx or extended index table); in case of a
symbol in a non-allocated section, *SHNDXP is instead set to -1.
Note that since symbols can come from either the main, debug or auxiliary
ELF symbol file (either dynsym or symtab) the section index can only
be reliably used to compare against special section constants like
SHN_UNDEF or SHN_ABS. It is recommended to use dwfl_module_getsym_info
which doesn't have these deficiencies. */
extern const char *dwfl_module_getsym (Dwfl_Module *mod, int ndx,
GElf_Sym *sym, GElf_Word *shndxp)
__nonnull_attribute__ (3);
/* Fetch one entry from the module's symbol table and the associated
address value. On errors, returns NULL. If successful, fills in
*SYM, *ADDR and returns the string for st_name. This works like
gelf_getsym. *ADDR is set to the st_value adjusted to an absolute
value based on the module's location, when the symbol is in an
SHF_ALLOC section. For non-ET_REL files, if the arch uses function
descriptors, and the st_value points to one, *ADDR will be resolved
to the actual function entry address. The SYM->ST_VALUE itself
isn't adjusted in any way. Fills in ELFP, if not NULL, with the
ELF file the symbol originally came from. Note that symbols can
come from either the main, debug or auxiliary ELF symbol file
(either dynsym or symtab). If SHNDXP is non-null, it's set with
the section index (whether from st_shndx or extended index table);
in case of a symbol in a non-allocated section, *SHNDXP is instead
set to -1. Fills in BIAS, if not NULL, with the difference between
addresses within the loaded module and those in symbol table of the
ELF file. Note that the address associated with the symbol might
be in a different section than the returned symbol. The section in
the main elf file in which returned ADDR falls can be found with
dwfl_module_address_section. */
extern const char *dwfl_module_getsym_info (Dwfl_Module *mod, int ndx,
GElf_Sym *sym, GElf_Addr *addr,
GElf_Word *shndxp,
Elf **elfp, Dwarf_Addr *bias)
__nonnull_attribute__ (3, 4);
/* Find the symbol that ADDRESS lies inside, and return its name. */
extern const char *dwfl_module_addrname (Dwfl_Module *mod, GElf_Addr address);
/* Find the symbol associated with ADDRESS. Return its name or NULL
when nothing was found. If the architecture uses function
descriptors, and symbol st_value points to one, ADDRESS will be
matched against either the adjusted st_value or the associated
function entry value as described in dwfl_module_getsym_info.
OFFSET will be filled in with the difference from the start of the
symbol (or function entry), OFFSET cannot be NULL. SYM is filled
in with the symbol associated with the matched ADDRESS, SYM cannot
be NULL. The SYM->ST_VALUE itself isn't adjusted in any way.
Fills in ELFP, if not NULL, with the ELF file the symbol originally
came from. Note that symbols can come from either the main, debug
or auxiliary ELF symbol file (either dynsym or symtab). If SHNDXP
is non-null, it's set with the section index (whether from st_shndx
or extended index table). Fills in BIAS, if not NULL, with the
difference between addresses within the loaded module and those in
symbol table of the ELF file. Note that the address matched
against the symbol might be in a different section than the
returned symbol. The section in the main elf file in ADDRESS falls
can be found with dwfl_module_address_section. */
extern const char *dwfl_module_addrinfo (Dwfl_Module *mod, GElf_Addr address,
GElf_Off *offset, GElf_Sym *sym,
GElf_Word *shndxp, Elf **elfp,
Dwarf_Addr *bias)
__nonnull_attribute__ (3, 4);
/* Find the symbol that ADDRESS lies inside, and return detailed
information as for dwfl_module_getsym (above). Note that like
dwfl_module_getsym this function also adjusts SYM->ST_VALUE to an
absolute value based on the module's location. ADDRESS is only
matched against this adjusted SYM->ST_VALUE. This means that
depending on architecture this might only match symbols that
represent function descriptor addresses (and not function entry
addresses). For these reasons it is recommended to use
dwfl_module_addrinfo instead. */
extern const char *dwfl_module_addrsym (Dwfl_Module *mod, GElf_Addr address,
GElf_Sym *sym, GElf_Word *shndxp)
__nonnull_attribute__ (3);
/* Find the ELF section that *ADDRESS lies inside and return it.
On success, adjusts *ADDRESS to be relative to the section,
and sets *BIAS to the difference between addresses used in
the returned section's headers and run-time addresses. */
extern Elf_Scn *dwfl_module_address_section (Dwfl_Module *mod,
Dwarf_Addr *address,
Dwarf_Addr *bias)
__nonnull_attribute__ (2, 3);
/*** Dwarf access functions ***/
/* Fetch the module's debug information for use with libdw.
If successful, fills in *BIAS with the difference between
addresses within the loaded module and those to use with libdw. */
extern Dwarf *dwfl_module_getdwarf (Dwfl_Module *, Dwarf_Addr *bias)
__nonnull_attribute__ (2);
/* Get the libdw handle for each module. */
extern ptrdiff_t dwfl_getdwarf (Dwfl *,
int (*callback) (Dwfl_Module *, void **,
const char *, Dwarf_Addr,
Dwarf *, Dwarf_Addr, void *),
void *arg, ptrdiff_t offset);
/* Look up the module containing ADDR and return its debugging information,
loading it if necessary. */
extern Dwarf *dwfl_addrdwarf (Dwfl *dwfl, Dwarf_Addr addr, Dwarf_Addr *bias)
__nonnull_attribute__ (3);
/* Find the CU containing ADDR and return its DIE. */
extern Dwarf_Die *dwfl_addrdie (Dwfl *dwfl, Dwarf_Addr addr, Dwarf_Addr *bias)
__nonnull_attribute__ (3);
extern Dwarf_Die *dwfl_module_addrdie (Dwfl_Module *mod,
Dwarf_Addr addr, Dwarf_Addr *bias)
__nonnull_attribute__ (3);
/* Iterate through the CUs, start with null for LASTCU. */
extern Dwarf_Die *dwfl_nextcu (Dwfl *dwfl, Dwarf_Die *lastcu, Dwarf_Addr *bias)
__nonnull_attribute__ (3);
extern Dwarf_Die *dwfl_module_nextcu (Dwfl_Module *mod,
Dwarf_Die *lastcu, Dwarf_Addr *bias)
__nonnull_attribute__ (3);
/* Return the module containing the CU DIE. */
extern Dwfl_Module *dwfl_cumodule (Dwarf_Die *cudie);
/* Cache the source line information for the CU and return the
number of Dwfl_Line entries it has. */
extern int dwfl_getsrclines (Dwarf_Die *cudie, size_t *nlines);
/* Access one line number entry within the CU. */
extern Dwfl_Line *dwfl_onesrcline (Dwarf_Die *cudie, size_t idx);
/* Get source for address. */
extern Dwfl_Line *dwfl_module_getsrc (Dwfl_Module *mod, Dwarf_Addr addr);
extern Dwfl_Line *dwfl_getsrc (Dwfl *dwfl, Dwarf_Addr addr);
/* Get address for source. */
extern int dwfl_module_getsrc_file (Dwfl_Module *mod,
const char *fname, int lineno, int column,
Dwfl_Line ***srcsp, size_t *nsrcs);
/* Return the module containing this line record. */
extern Dwfl_Module *dwfl_linemodule (Dwfl_Line *line);
/* Return the CU containing this line record. */
extern Dwarf_Die *dwfl_linecu (Dwfl_Line *line);
/* Return the source file name and fill in other information.
Arguments may be null for unneeded fields. */
extern const char *dwfl_lineinfo (Dwfl_Line *line, Dwarf_Addr *addr,
int *linep, int *colp,
Dwarf_Word *mtime, Dwarf_Word *length);
/* Return the equivalent Dwarf_Line and the bias to apply to its address. */
extern Dwarf_Line *dwfl_dwarf_line (Dwfl_Line *line, Dwarf_Addr *bias);
/* Return the compilation directory (AT_comp_dir) from this line's CU. */
extern const char *dwfl_line_comp_dir (Dwfl_Line *line);
/*** Machine backend access functions ***/
/* Return location expression to find return value given a
DW_TAG_subprogram, DW_TAG_subroutine_type, or similar DIE describing
function itself (whose DW_AT_type attribute describes its return type).
The given DIE must come from the given module. Returns -1 for errors.
Returns zero if the function has no return value (e.g. "void" in C).
Otherwise, *LOCOPS gets a location expression to find the return value,
and returns the number of operations in the expression. The pointer is
permanently allocated at least as long as the module is live. */
extern int dwfl_module_return_value_location (Dwfl_Module *mod,
Dwarf_Die *functypedie,
const Dwarf_Op **locops);
/* Enumerate the DWARF register numbers and their names.
For each register, CALLBACK gets its DWARF number, a string describing
the register set (such as "integer" or "FPU"), a prefix used in
assembler syntax (such as "%" or "$", may be ""), and the name for the
register (contains identifier characters only, possibly all digits).
The REGNAME string is valid only during the callback. */
extern int dwfl_module_register_names (Dwfl_Module *mod,
int (*callback) (void *arg,
int regno,
const char *setname,
const char *prefix,
const char *regname,
int bits, int type),
void *arg);
/* Find the CFI for this module. Returns NULL if there is no CFI.
On success, fills in *BIAS with the difference between addresses
within the loaded module and those in the CFI referring to it.
The pointer returned can be used until the module is cleaned up.
Calling these more than once returns the same pointers.
dwfl_module_dwarf_cfi gets the '.debug_frame' information found with the
rest of the DWARF information. dwfl_module_eh_cfi gets the '.eh_frame'
information found linked into the text. A module might have either or
both. */
extern Dwarf_CFI *dwfl_module_dwarf_cfi (Dwfl_Module *mod, Dwarf_Addr *bias);
extern Dwarf_CFI *dwfl_module_eh_cfi (Dwfl_Module *mod, Dwarf_Addr *bias);
typedef struct
{
/* Called to iterate through threads. Returns next TID (thread ID) on
success, a negative number on failure and zero if there are no more
threads. dwfl_errno () should be set if negative number has been
returned. *THREAD_ARGP is NULL on first call, and may be optionally
set by the implementation. The value set by the implementation will
be passed in on the next call to NEXT_THREAD. THREAD_ARGP is never
NULL. *THREAD_ARGP will be passed to set_initial_registers or
thread_detach callbacks together with Dwfl_Thread *thread. This
method must not be NULL. */
pid_t (*next_thread) (Dwfl *dwfl, void *dwfl_arg, void **thread_argp)
__nonnull_attribute__ (1);
/* Called to get a specific thread. Returns true if there is a
thread with the given thread id number, returns false if no such
thread exists and will set dwfl_errno in that case. THREAD_ARGP
is never NULL. *THREAD_ARGP will be passed to
set_initial_registers or thread_detach callbacks together with
Dwfl_Thread *thread. This method may be NULL and will then be
emulated using the next_thread callback. */
bool (*get_thread) (Dwfl *dwfl, pid_t tid, void *dwfl_arg,
void **thread_argp)
__nonnull_attribute__ (1);
/* Called during unwinding to access memory (stack) state. Returns true for
successfully read *RESULT or false and sets dwfl_errno () on failure.
This method may be NULL - in such case dwfl_thread_getframes will return
only the initial frame. */
bool (*memory_read) (Dwfl *dwfl, Dwarf_Addr addr, Dwarf_Word *result,
void *dwfl_arg)
__nonnull_attribute__ (1, 3);
/* Called on initial unwind to get the initial register state of the first
frame. Should call dwfl_thread_state_registers, possibly multiple times
for different ranges and possibly also dwfl_thread_state_register_pc, to
fill in initial (DWARF) register values. After this call, till at least
thread_detach is called, the thread is assumed to be frozen, so that it is
safe to unwind. Returns true on success or false and sets dwfl_errno ()
on failure. In the case of a failure thread_detach will not be called.
This method must not be NULL. */
bool (*set_initial_registers) (Dwfl_Thread *thread, void *thread_arg)
__nonnull_attribute__ (1);
/* Called by dwfl_end. All thread_detach method calls have been already
done. This method may be NULL. */
void (*detach) (Dwfl *dwfl, void *dwfl_arg)
__nonnull_attribute__ (1);
/* Called when unwinding is done. No callback will be called after
this method has been called. Iff set_initial_registers was called for
a TID and it returned success thread_detach will be called before the
detach method above. This method may be NULL. */
void (*thread_detach) (Dwfl_Thread *thread, void *thread_arg)
__nonnull_attribute__ (1);
} Dwfl_Thread_Callbacks;
/* PID is the process id associated with the DWFL state. Architecture of DWFL
modules is specified by ELF, ELF must remain valid during DWFL lifetime.
Use NULL ELF to detect architecture from DWFL, the function will then detect
it from arbitrary Dwfl_Module of DWFL. DWFL_ARG is the callback backend
state. DWFL_ARG will be provided to the callbacks. *THREAD_CALLBACKS
function pointers must remain valid during lifetime of DWFL. Function
returns true on success, false otherwise. */
bool dwfl_attach_state (Dwfl *dwfl, Elf *elf, pid_t pid,
const Dwfl_Thread_Callbacks *thread_callbacks,
void *dwfl_arg)
__nonnull_attribute__ (1, 4);
/* Calls dwfl_attach_state with Dwfl_Thread_Callbacks setup for extracting
thread state from the ELF core file. Returns the pid number extracted
from the core file, or -1 for errors. */
extern int dwfl_core_file_attach (Dwfl *dwfl, Elf *elf);
/* Calls dwfl_attach_state with Dwfl_Thread_Callbacks setup for extracting
thread state from the proc file system. Uses ptrace to attach and stop
the thread under inspection and detaches when thread_detach is called
and unwinding for the thread is done, unless ASSUME_PTRACE_STOPPED is
true. If ASSUME_PTRACE_STOPPED is true the caller should make sure that
the thread is ptrace attached and stopped before unwinding by calling
either dwfl_thread_getframes or dwfl_getthread_frames. Returns zero on
success, -1 if dwfl_attach_state failed, or an errno code if opening the
proc files failed. */
extern int dwfl_linux_proc_attach (Dwfl *dwfl, pid_t pid,
bool assume_ptrace_stopped);
/* Return PID for the process associated with DWFL. Function returns -1 if
dwfl_attach_state was not called for DWFL. */
pid_t dwfl_pid (Dwfl *dwfl)
__nonnull_attribute__ (1);
/* Return DWFL from which THREAD was created using dwfl_getthreads. */
Dwfl *dwfl_thread_dwfl (Dwfl_Thread *thread)
__nonnull_attribute__ (1);
/* Return positive TID (thread ID) for THREAD. This function never fails. */
pid_t dwfl_thread_tid (Dwfl_Thread *thread)
__nonnull_attribute__ (1);
/* Return thread for frame STATE. This function never fails. */
Dwfl_Thread *dwfl_frame_thread (Dwfl_Frame *state)
__nonnull_attribute__ (1);
/* Called by Dwfl_Thread_Callbacks.set_initial_registers implementation.
For every known continuous block of registers <FIRSTREG..FIRSTREG+NREGS)
(inclusive..exclusive) set their content to REGS (array of NREGS items).
Function returns false if any of the registers has invalid number. */
bool dwfl_thread_state_registers (Dwfl_Thread *thread, int firstreg,
unsigned nregs, const Dwarf_Word *regs)
__nonnull_attribute__ (1, 4);
/* Called by Dwfl_Thread_Callbacks.set_initial_registers implementation.
If PC is not contained among DWARF registers passed by
dwfl_thread_state_registers on the target architecture pass the PC value
here. */
void dwfl_thread_state_register_pc (Dwfl_Thread *thread, Dwarf_Word pc)
__nonnull_attribute__ (1);
/* Iterate through the threads for a process. Returns zero if all threads have
been processed by the callback, returns -1 on error, or the value of the
callback when not DWARF_CB_OK. -1 returned on error will set dwfl_errno ().
Keeps calling the callback with the next thread while the callback returns
DWARF_CB_OK, till there are no more threads. */
int dwfl_getthreads (Dwfl *dwfl,
int (*callback) (Dwfl_Thread *thread, void *arg),
void *arg)
__nonnull_attribute__ (1, 2);
/* Iterate through the frames for a thread. Returns zero if all frames
have been processed by the callback, returns -1 on error, or the value of
the callback when not DWARF_CB_OK. -1 returned on error will
set dwfl_errno (). Some systems return error instead of zero on end of the
backtrace, for cross-platform compatibility callers should consider error as
a zero. Keeps calling the callback with the next frame while the callback
returns DWARF_CB_OK, till there are no more frames. On start will call the
set_initial_registers callback and on return will call the detach_thread
callback of the Dwfl_Thread. */
int dwfl_thread_getframes (Dwfl_Thread *thread,
int (*callback) (Dwfl_Frame *state, void *arg),
void *arg)
__nonnull_attribute__ (1, 2);
/* Like dwfl_thread_getframes, but specifying the thread by its unique
identifier number. Returns zero if all frames have been processed
by the callback, returns -1 on error (and when no thread with
the given thread id number exists), or the value of the callback
when not DWARF_CB_OK. -1 returned on error will set dwfl_errno (). */
int dwfl_getthread_frames (Dwfl *dwfl, pid_t tid,
int (*callback) (Dwfl_Frame *thread, void *arg),
void *arg)
__nonnull_attribute__ (1, 3);
/* Return *PC (program counter) for thread-specific frame STATE.
Set *ISACTIVATION according to DWARF frame "activation" definition.
Typically you need to subtract 1 from *PC if *ACTIVATION is false to safely
find function of the caller. ACTIVATION may be NULL. PC must not be NULL.
Function returns false if it failed to find *PC. */
bool dwfl_frame_pc (Dwfl_Frame *state, Dwarf_Addr *pc, bool *isactivation)
__nonnull_attribute__ (1, 2);
/* Get the value of the DWARF register number in the given frame.
Returns zero on success, -1 on error (invalid DWARF register
number) or 1 if the value of the register in the frame is unknown. */
int dwfl_frame_reg (Dwfl_Frame *state, unsigned regno, Dwarf_Word *val)
__nonnull_attribute__ (1);
/* Return the internal debuginfod-client connection handle for the DWFL session.
When the client connection has not yet been initialized, it will be done on the
first call to this function. If elfutils is compiled without support for debuginfod,
NULL will be returned.
*/
extern debuginfod_client *dwfl_get_debuginfod_client (Dwfl *dwfl);
#ifdef __cplusplus
}
#endif
#endif /* libdwfl.h */
PK �zFZ��ǻ] ] debuginfod.hnu �[��� PK �zFZ��x�W W � elf-knowledge.hnu �[��� PK �zFZ\~\�k� k�
/! known-dwarf.hnu �[��� PK �zFZ$�s� � �� version.hnu �[��� PK �zFZ8��6 6
� libdwelf.hnu �[��� PK �zFZ����� � z� libasm.hnu �[��� PK �zFZ�$[Tز ز ~ libdw.hnu �[��� PK �zFZ��i�ؖ ؖ �� libdwfl.hnu �[��� PK S �L