/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright (c) 2015, Joyent, Inc. All rights reserved.
*/
/*
* Dump an elf file.
*/
#include <stddef.h>
#include <sys/elf_amd64.h>
#include <sys/elf_SPARC.h>
#include <_libelf.h>
#include <dwarf.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <strings.h>
#include <debug.h>
#include <conv.h>
#include <msg.h>
#include <_elfdump.h>
/*
* VERSYM_STATE is used to maintain information about the VERSYM section
* in the object being analyzed. It is filled in by versions(), and used
* by init_symtbl_state() when displaying symbol information.
*
* There are three forms of symbol versioning known to us:
*
* 1) The original form, introduced with Solaris 2.5, in which
* the Versym contains indexes to Verdef records, and the
* Versym values for UNDEF symbols resolved by other objects
* are all set to 0.
* 2) The GNU form, which is backward compatible with the original
* Solaris form, but which adds several extensions:
* - The Versym also contains indexes to Verneed records, recording
* link time. These indexes start with the next value following
* the final Verdef index. The index is written to the previously
* reserved vna_other field of the ELF Vernaux structure.
* - The top bit of the Versym value is no longer part of the index,
* but is used as a "hidden bit" to prevent binding to the symbol.
* - Multiple implementations of a given symbol, contained in varying
* versions are allowed, using special assembler pseudo ops,
* and encoded in the symbol name using '@' characters.
* 3) Modified Solaris form, in which we adopt the first GNU extension
* (Versym indexes to Verneed records), but not the others.
*
* elfdump can handle any of these cases. The presence of a DT_VERSYM
* dynamic element indicates a full GNU object. An object that lacks
* a DT_VERSYM entry, but which has non-zero vna_other fields in the Vernaux
* structures is a modified Solaris object. An object that has neither of
* these uses the original form.
*
* max_verndx contains the largest version index that can appear
* in a Versym entry. This can never be less than 1: In the case where
* for local symbols, and the [1] index for globals. If the original
* Solaris versioning rules are in effect and there is a verdef section,
* then max_verndex is the number of defined versions. If one of the
* other versioning forms is in effect, then:
* 1) If there is no verneed section, it is the same as for
* original Solaris versioning.
* 2) If there is a verneed section, the vna_other field of the
* Vernaux structs contain versions, and max_verndx is the
* largest such index.
*
* If gnu_full is True, the object uses the full GNU form of versioning.
* The value of the gnu_full field is based on the presence of
* a DT_VERSYM entry in the dynamic section: GNU ld produces these, and
* Solaris ld does not.
*
* The gnu_needed field is True if the Versym contains indexes to
* Verneed records, as indicated by non-zero vna_other fields in the Verneed
* section. If gnu_full is True, then gnu_needed will always be true.
* However, gnu_needed can be true without gnu_full. This is the modified
* Solaris form.
*/
typedef struct {
/* VERNEED (subset of gnu_full) */
} VERSYM_STATE;
/*
* SYMTBL_STATE is used to maintain information about a single symbol
* table section, for use by the routines that display symbol information.
*/
typedef struct {
struct { /* Extended section index data */
/* used for symbol table entries */
uint_t n; /* # items in shxndx.data */
} shxndx;
} SYMTBL_STATE;
/*
* A variable of this type is used to track information related to
* .eh_frame and .eh_frame_hdr sections across calls to unwind_eh_frame().
*/
typedef struct {
/* .eh_frame_hdr section */
/*
* C++ .exception_ranges entries make use of the signed ptrdiff_t
* type to record self-relative pointer values. We need a type
* for this that is matched to the ELFCLASS being processed.
*/
#if defined(_ELF64)
#else
#endif
/*
* The Sun C++ ABI uses this struct to define each .exception_ranges
* entry. From the ABI:
*
* The field ret_addr is a self relative pointer to the start of the address
* range. The name was chosen because in the current implementation the range
* typically starts at the return address for a call site.
*
* The field length is the difference, in bytes, between the pc of the last
* instruction covered by the exception range and the first. When only a
* single call site is represented without optimization, this will equal zero.
*
* The field handler_addr is a relative pointer which stores the difference
* between the start of the exception range and the address of all code to
* catch exceptions and perform the cleanup for stack unwinding.
*
* The field type_block is a relative pointer which stores the difference
* between the start of the exception range and the address of an array used
* for storing a list of the types of exceptions which can be caught within
* the exception range.
*/
typedef struct {
/*
* Focal point for verifying symbol names.
*/
static const char *
{
/*
* If an error in this routine is due to a property of the string
* section, as opposed to a bad offset into the section (a property of
* the referencing section), then we will detect the same error on
* every call involving those sections. We use these static variables
* to retain the information needed to only issue each such error once.
*/
const char *strs;
return (NULL);
/*
* We only print a diagnostic regarding a bad string table once per
* input section being processed. If the refsec has changed, reset
* our retained error state.
*/
if (last_refsec != refsec) {
strsec_err = 0;
}
/* Verify that strsec really is a string table */
if (!strsec_err) {
strsec_err = 1;
}
return (MSG_INTL(MSG_STR_UNKNOWN));
}
/*
* Is the string table offset within range of the available strings?
*/
/*
* Do we have a empty string table?
*/
if (!strsec_err) {
strsec_err = 1;
}
} else {
}
/*
* Return the empty string so that the calling function can
* continue it's output diagnostics.
*/
return (MSG_INTL(MSG_STR_UNKNOWN));
}
}
/*
* Relocations can reference section symbols and standard symbols. If the
* former, establish the section name.
*/
static const char *
{
const char *name;
return (MSG_INTL(MSG_STR_UNKNOWN));
}
/*
* If the symbol represents a section offset construct an appropriate
* string. Note, although section symbol table entries typically have
* a NULL name pointer, entries do exist that point into the string
* table to their own NULL strings.
*/
return ((const char *)secstr);
}
return (name);
}
/*
* Focal point for establishing a string table section. Data such as the
* dynamic information simply points to a string table. Data such as
* relocations, reference a symbol table, which in turn is associated with a
* string table.
*/
static int
{
/*
* If symtab is non-zero, the ndx we are called with represents a
* shdr which links to a symbol table (which then links to a string
* table)
*/
if (symtab != 0) {
/*
* Validate the symbol table linkage.
*/
return (0);
}
/*
* Establish the symbol table index.
*/
return (0);
}
/*
* Obtain, and verify the symbol table data.
*/
return (0);
}
/*
* Return symbol table information.
*/
if (symnum)
if (symsec)
}
/*
* Validate the string table linkage.
*/
return (0);
}
if (strsec)
return (1);
}
/*
* Lookup a symbol and set Sym accordingly.
*
* entry:
* name - Name of symbol to lookup
* cache - Cache of all section headers
* shnum - # of sections in cache
* sym - Address of pointer to receive symbol
* target - NULL, or section to which the symbol must be associated.
* symtab - Symbol table to search for symbol
* file - Name of file
*
* exit:
* If the symbol is found, *sym is set to reference it, and True is
* returned. If target is non-NULL, the symbol must reference the given
* section --- otherwise the section is not checked.
*
* If no symbol is found, False is returned.
*/
static int
{
if (symtab == 0)
return (0);
/*
* Determine the symbol data and number.
*/
return (0);
}
return (0);
/* LINTED */
/*
* Get the associated string table section.
*/
return (0);
}
/*
* Loop through the symbol table to find a match.
*/
const char *symname;
/*
* It is possible, though rare, for a local and
* global symbol of the same name to exist, each
* contributed by a different input object. If the
* symbol just found is local, remember it, but
* continue looking.
*/
break;
}
}
}
/*
* Print section headers.
*/
static void
{
/*
* Although numerous section header entries can be zero, it's
* usually a sign of trouble if the type is zero.
*/
}
continue;
/*
* Identify any sections that are suspicious. A .got section
* shouldn't exist in a relocatable object.
*/
MSG_ELF_GOT_SIZE) == 0) {
secname);
}
}
}
}
/*
* Obtain a specified Phdr entry.
*/
static Phdr *
{
return (NULL);
}
return (phdr);
}
}
return (NULL);
}
/*
* sections.
*
* entry:
* cache - Cache of all section headers
* shndx - Index of .eh_frame or .eh_frame_hdr section to be displayed
* shnum - Total number of sections which exist
* uphdr - NULL, or unwind program header associated with
* the .eh_frame_hdr section.
* ehdr - ELF header for file
* eh_state - Data used across calls to this routine. The
* caller should zero it before the first call, and
* pass it on every call.
* osabi - OSABI to use in displaying information
* file - Name of file
* flags - Command line option flags
*/
static void
{
#if defined(_ELF64)
#else
#endif
int cnt;
MSG_ELF_GOT_SIZE) == 0) {
break;
}
}
return;
}
/*
* Is this a .eh_frame_hdr?
*/
MSG_SCN_FRMHDR_SIZE) == 0)) {
/*
* There can only be a single .eh_frame_hdr.
* Flag duplicates.
*/
ndx = 0;
case DW_OVERFLOW:
return;
case DW_BAD_ENCODING:
return;
case DW_SUCCESS:
break;
}
}
gotaddr)) {
case DW_OVERFLOW:
return;
case DW_BAD_ENCODING:
return;
case DW_SUCCESS:
break;
}
case DW_OVERFLOW:
return;
case DW_BAD_ENCODING:
return;
case DW_SUCCESS:
break;
}
case DW_OVERFLOW:
return;
case DW_BAD_ENCODING:
return;
case DW_SUCCESS:
break;
}
}
} else { /* Display the .eh_frame section */
}
}
/*
* If we've seen the .eh_frame_hdr and the first .eh_frame section,
* compare the header frame_ptr to the address of the actual frame
* section to ensure the link-editor got this right. Note, this
* diagnostic is only produced when unwind information is explicitly
* asked for, as shared objects built with an older ld(1) may reveal
* this inconsistency. Although an inconsistency, it doesn't seem to
* have any adverse effect on existing tools.
*/
}
/*
* Convert a self relative pointer into an address. A self relative
* pointer adds the address where the pointer resides to the offset
* contained in the pointer. The benefit is that the value of the
* pointer does not require relocation.
*
* entry:
* base_addr - Address of the pointer.
* delta - Offset relative to base_addr giving desired address
*
* exit:
* The computed address is returned.
*
* note:
* base_addr is an unsigned value, while ret_addr is signed. This routine
* used explicit testing and casting to explicitly control type
* conversion, and ensure that we handle the maximum possible range.
*/
static Addr
{
if (delta < 0)
}
/*
* Byte swap a PTRDIFF_T value.
*/
static PTRDIFF_T
{
PTRDIFF_T r;
return (r);
}
/*
* Display exception_range_entry items from the .exception_ranges section
* of a Sun C++ object.
*/
static void
{
/*
* Translate a PTRDIFF_T self-relative address field of
* an exception_range_entry struct into an address.
*
* entry:
* exc_addr - Address of base of exception_range_entry struct
* cur_ent - Pointer to data in the struct to be translated
*
* _f - Field of struct to be translated
*/
#if defined(_ELF64)
#else
#define MSG_EXR_TITLE MSG_EXR_TITLE_32
#define MSG_EXR_ENTRY MSG_EXR_ENTRY_32
#endif
if (do_swap) {
/*
* Copy byte swapped values into the scratch buffer.
* The reserved field is not used, so we skip it.
*/
} else {
}
/*
* The table is required to be sorted by the address
* derived from ret_addr, to allow binary searching. Ensure
* that addresses grow monotonically.
*/
EC_XWORD(i));
exc_addr += sizeof (exception_range_entry);
offset += sizeof (exception_range_entry);
}
}
/*
*
* - Sun C++ .exception_ranges
*
*/
static void
{
/*
* Historical background: .eh_frame and .eh_frame_hdr sections
* come from the GNU compilers (particularly C++), and are used
* under all architectures. Their format is based on DWARF. When
* the amd64 ABI was defined, these sections were adopted wholesale
* from the existing practice.
*
* When amd64 support was added to Solaris, support for these
* sections was added, using the SHT_AMD64_UNWIND section type
* to identify them. At first, we ignored them in objects for
* non-amd64 targets, but later broadened our support to include
* other architectures in order to better support gcc-generated
* objects.
*
* .exception_ranges implement the same basic concepts, but
* were invented at Sun for the Sun C++ compiler.
*
* We match these sections by name, rather than section type,
* because they can come in as either SHT_AMD64_UNWIND, or as
* SHT_PROGBITS, and because the type isn't enough to determine
* how they should be interpreted.
*/
/* Find the program header for .eh_frame_hdr if present */
if (phnum)
/*
* eh_state is used to retain data used by unwind_eh_frame()
* across calls.
*/
int is_exrange;
/*
* Skip sections of the wrong type. On amd64, they
* can be SHT_AMD64_UNWIND. On all platforms, they
* can be SHT_PROGBITS (including amd64, if using
* the GNU compilers).
*
* Skip anything other than these two types. The name
* test below will thin out the SHT_PROGBITS that don't apply.
*/
continue;
/*
* Only sections with certain well known names are of interest.
* These are:
*
* .eh_frame - amd64/GNU-compiler unwind sections
* .eh_frame_hdr - Sorted table referencing .eh_frame
* .exception_ranges - Sun C++ unwind sections
*
* We do a prefix comparison, allowing for naming conventions
* like .eh_frame.foo, hence the use of strncmp() rather than
* strcmp(). This means that we only really need to test for
* .eh_frame, as it's a prefix of .eh_frame_hdr.
*/
MSG_SCN_FRM_SIZE) != 0) && !is_exrange)
continue;
continue;
continue;
if (is_exrange)
else
}
}
/*
* Initialize a symbol table state structure
*
* entry:
* state - State structure to be initialized
* cache - Cache of all section headers
* shnum - # of sections in cache
* secndx - Index of symbol table section
* ehdr - ELF header for file
* versym - Information about versym section
* file - Name of file
* flags - Command line option flags
*/
static int
{
/*
* Check the symbol data and per-item size.
*/
return (0);
}
return (0);
/* LINTED */
/*
* Check associated string table section.
*/
return (0);
}
/*
* Determine if there is a associated Versym section
* with this Symbol Table.
*/
else
return (1);
}
/*
* Determine the extended section index used for symbol tables entries.
*/
static void
{
continue;
if ((shdr->sh_entsize) &&
/* LINTED */
continue;
continue;
return;
}
}
/*
* Produce a line of output for the given symbol
*
* entry:
* state - Symbol table state
* symndx - Index of symbol within the table
* symndx_disp - Index to display. This may not be the same
* as symndx if the display is relative to the logical
* combination of the SUNW_ldynsym/dynsym tables.
* sym - Symbol to display
*/
static void
{
/*
* Symbol types for which we check that the specified
*/
static const int addr_symtype[] = {
0, /* STT_NOTYPE */
1, /* STT_OBJECT */
1, /* STT_FUNC */
0, /* STT_SECTION */
0, /* STT_FILE */
1, /* STT_COMMON */
0, /* STT_TLS */
0, /* 7 */
0, /* 8 */
0, /* 9 */
0, /* 10 */
0, /* 11 */
0, /* 12 */
0, /* STT_SPARC_REGISTER */
0, /* 14 */
0, /* 15 */
};
#error "STT_NUM has grown. Update addr_symtype[]"
#endif
int gnuver;
/* Ensure symbol index is in range */
return;
}
/*
* If we are using extended symbol indexes, find the
* corresponding SHN_SYMTAB_SHNDX table.
*/
/* LINTED */
/*
* If we are using fake section headers derived from
* the program headers, then the section indexes
* in the symbols do not correspond to these headers.
* The section names are not available, so all we can
* do is to display them in numeric form.
*/
} else if ((_shxndx =
} else {
}
} else {
}
}
/*
* If versioning is available display the
* version index. If not, then use 0.
*/
/*
* Check to see if this is a defined symbol with a
* version index that is outside the valid range for
* the file. The interpretation of this depends on
* the style of versioning used by the object.
*
* Versions >= VER_NDX_LORESERVE have special meanings,
* and are exempt from this checking.
*
* GNU style version indexes use the top bit of the
* 16-bit index value (0x8000) as the "hidden bit".
* We must mask off this bit in order to compare
* the version against the maximum value.
*/
if (gnuver)
test_verndx &= ~0x8000;
(verndx < VER_NDX_LORESERVE))
} else {
verndx = 0;
gnuver = 0;
}
/*
* Error checking for TLS.
*/
if (tshdr &&
}
}
/*
* If a symbol with non-zero size has a type that
* specifies an address, then make sure the location
* it references is actually contained within the
* section. UNDEF symbols don't count in this case,
* so we ignore them.
*
* The meaning of the st_value field in a symbol
* depends on the type of object. For a relocatable
* object, it is the offset within the section.
* For sharable objects, it is the offset relative to
* the base of the object, and for other types, it is
* the virtual address. To get an offset within the
* section for non-ET_REL files, we subtract the
* base address of the section.
*/
}
}
/*
* A typical symbol table uses the sh_info field to indicate one greater
* than the symbol table index of the last local symbol, STB_LOCAL.
* Therefore, symbol indexes less than sh_info should have local
* binding. Symbol indexes greater than, or equal to sh_info, should
* value and size, as these symbols may be the result of an mcs(1)
* section deletion.
*/
if (info) {
}
}
}
/*
* Process a SHT_SUNW_cap capabilities section.
*/
static int
{
return (0);
}
/*
* If this capabilities section is associated with symbols, then the
* sh_link field points to the associated capabilities information
* section. The sh_link field of the capabilities information section
* points to the associated symbol table.
*/
/*
* Validate that the sh_link field points to a capabilities
* information section.
*/
return (0);
}
return (0);
}
/*
* Validate that the sh_link field of the capabilities
* information section points to a valid symbol table.
*/
return (0);
}
return (0);
}
return (0);
}
/*
* If this capabilities section contains capability string entries,
* then determine the associated string table. Capabilities entries
* that define names require that the capability section indicate
* which string table to use via sh_info.
*/
/*
* Validate that the sh_info field points to a string table.
*/
return (0);
}
return (0);
}
}
descapndx = -1;
/*
* Traverse the capabilities section printing each capability group.
* The first capabilities group defines any object capabilities. Any
* following groups define symbol capabilities. In the case where no
* object capabilities exist, but symbol capabilities do, a single
* CA_SUNW_NULL terminator for the object capabilities exists.
*/
/*
* A CA_SUNW_NULL tag terminates a capabilities group.
* If the first capabilities tag is CA_SUNW_NULL, then
* no object capabilities exist.
*/
objcap = 0;
title = 1;
} else {
if (title) {
if (nulls == 0) {
/*
* If this capabilities group represents
* the object capabilities (i.e., no
* CA_SUNW_NULL tag has been processed
* yet), then display an object
* capabilities title.
*/
dbg_print(0,
} else {
/*
* If this is a symbols capabilities
* group (i.e., a CA_SUNW_NULL tag has
* already be found that terminates
* the object capabilities group), then
* display a symbol capabilities title,
* and retain this capabilities index
* for later processing.
*/
dbg_print(0,
}
Elf_cap_title(0);
title = 0;
}
/*
* Print the capabilities data.
*
* Note that CA_SUNW_PLAT, CA_SUNW_MACH and CA_SUNW_ID
* entries require a string table, which should have
* already been established.
*/
}
}
/*
* If this CA_SUNW_NULL tag terminates a symbol capabilities
* group, determine the associated symbols.
*/
(descapndx != -1)) {
symcaps++;
/*
* Make sure we've discovered a SHT_SUNW_capinfo table.
*/
return (0);
}
/*
* Determine what symbols reference this capabilities
* group.
*/
}
}
descapndx = -1;
continue;
}
/*
* An SF1_SUNW_ADDR32 software capability tag in a 32-bit
* object is suspicious as it has no effect.
*/
}
}
/*
* If this is a dynamic object, with symbol capabilities, then a
* .SUNW_capchain section should exist. This section contains a chain
* of symbol indexes for each capabilities family. This is the list
* that is searched by ld.so.1 to determine the best capabilities
* candidate.
*
* Note, more than one capabilities lead symbol can point to the same
* represent the same family of capabilities symbols. Therefore, to
* display all possible families we traverse the capabilities
* information section looking for CAPINFO_SUNW_GLOB lead symbols.
* From these we determine the associated capabilities chain to inspect.
*/
if (symcaps &&
/*
* Validate that the sh_info field of the capabilities
* information section points to a capabilities chain section.
*/
return (0);
}
return (0);
}
/*
* Traverse the capabilities information section looking for
* CAPINFO_SUNW_GLOB lead capabilities symbols.
*/
const char *name;
continue;
/*
* Determine the symbol that is associated with this
* capability information entry, and use this to
* identify this capability family.
*/
/*
* Traverse this families chain and identify each
* family member.
*/
for (;;) {
break;
}
break;
/*
* Determine this entries symbol reference.
*/
} else {
}
/*
* Display the family member.
*/
cndx++;
}
}
}
return (objcap);
}
/*
* Print the capabilities.
*
* A .SUNW_cap section can contain one or more, CA_SUNW_NULL terminated,
* capabilities groups. The first group defines the object capabilities.
* This group defines the minimum capability requirements of the entire
* object file. If this is a dynamic object, this group should be associated
* with a PT_SUNWCAP program header.
*
* Additional capabilities groups define the association of individual symbols
* to specific capabilities.
*/
static void
{
/*
* Determine if a global capabilities header exists.
*/
if (phnum) {
return;
}
break;
}
}
}
/*
* Determine if a capabilities section exists.
*/
/*
* Process any capabilities information.
*/
/*
* If this section defined an object capability
* group, retain the section information for
* program header validation.
*/
}
continue;
}
}
return;
/*
* If this object is an executable or shared object, and it provided
* an object capabilities group, then the group should have an
* accompanying PT_SUNWCAP program header.
*/
if (cphdr_off == 0) {
}
}
}
/*
* Print the interpretor.
*/
static void
{
/*
* Determine if an interp header exists.
*/
if (phnum) {
}
}
if (iphdr_off == 0)
return;
/*
* Determine if an interp section exists.
*/
/*
* Scan sections to find a section which contains the PT_INTERP
* string. The target section can't be in a NOBITS section.
*/
continue;
break;
}
/*
* Print the interpreter string based on the offset defined in the
* program header, as this is the offset used by the kernel.
*/
} else
/*
* If there are any inconsistences between the program header and
* section information, flag them.
*/
}
}
/*
* Print the syminfo section.
*/
static void
{
break;
}
}
return;
return;
}
return;
/*
* If there is no associated dynamic section, determine if one
* is needed, and if so issue a warning. If there is an
* associated dynamic section, validate it and get the data buffer
* for it.
*/
dynnum = 0;
continue;
}
} else {
}
return;
}
/*
* We validate the type of dynamic elements referenced
* from the syminfo. This array is used report any
* bad dynamic entries.
*/
NULL) {
return;
}
}
}
/*
* Get the data buffer for the associated symbol table and string table.
*/
return;
/*
* Loop through the syminfo entries.
*/
continue;
/* Is si_boundto set to one of the reserved values? */
if (boundto >= SYMINFO_BT_LOWRESERVE) {
continue;
}
/*
* si_boundto is referencing a dynamic section. If we don't
* have one, an error was already issued above, so it suffices
* to display an empty string. If we are out of bounds, then
* report that and then display an empty string.
*/
continue;
}
/*
* The si_boundto reference expects a specific dynamic element
* type at the given index. The dynamic element is always a
* string that gives an object name. The specific type depends
* on the si_flags present. Ensure that we've got the right
* type.
*/
else
/* Only complain about each dynamic element once */
}
}
/*
* Whether or not the DT item we're pointing at is
* of the right type, if it's a type we recognize as
* providing a string, go ahead and show it. Otherwise
* an empty string.
*/
case DT_NEEDED:
case DT_SONAME:
case DT_RPATH:
case DT_RUNPATH:
case DT_CONFIG:
case DT_DEPAUDIT:
case DT_USED:
case DT_AUDIT:
case DT_SUNW_AUXILIARY:
case DT_SUNW_FILTER:
case DT_FILTER:
case DT_AUXILIARY:
break;
default:
}
}
}
/*
* Print version definition section entries.
*/
static void
const char *file)
{
/*
* Obtain the name and first dependency (if any).
*/
if (vcnt)
else
/*
* Print any additional dependencies.
*/
if (vcnt) {
}
}
}
}
/*
* Print version needed section entries.
*
* entry:
* vnd - Address of verneed data
* vnd_num - # of Verneed entries
* vcache - Cache of verneed section being processed
* scache - Cache of associated string table section
* file - Name of object being processed.
* versym - Information about versym section
*
* exit:
* The versions have been printed. If GNU style versioning
* is in effect, versym->max_verndx has been updated to
* contain the largest version index seen.
*
* note:
* The versym section of an object that follows the original
* Solaris versioning rules only contains indexes into the verdef
* section. Symbols defined in other objects (UNDEF) are given
* a version of 0, indicating that they are not defined by
* this file, and the Verneed entries do not have associated version
* indexes. For these reasons, we do not display a version index
* for original-style Verneed sections.
*
* The GNU versioning extensions alter this: Symbols defined in other
* objects receive a version index in the range above those defined
* by the Verdef section, and the vna_other field of the Vernaux
* structs inside the Verneed section contain the version index for
* that item. We therefore display the index when showing the
* contents of a GNU style Verneed section. You should not
* necessarily expect these indexes to appear in sorted
* order --- it seems that the GNU ld assigns the versions as
* symbols are encountered during linking, and then the results
* are assembled into the Verneed section afterwards.
*/
static void
{
const char *index_str;
/*
* Obtain the name of the needed file and the version name
* within it that we're dependent on. Note that the count
* should be at least one, otherwise this is a pretty bogus
* entry.
*/
if (vcnt)
else
} else { /* GNU form */
/* Format the version index value */
}
/*
* Print any additional version dependencies.
*/
if (vcnt) {
/* Format the next index value */
Elf_ver_line_1(0, index,
0, &ver_flags_buf));
versym->max_verndx =
} else {
0, &ver_flags_buf));
}
}
}
}
}
/*
* Examine the Verneed section for information related to GNU
* style Versym indexing:
* - A non-zero vna_other field indicates that Versym indexes can
* reference Verneed records.
* - If the object uses GNU style Versym indexing, the
* maximum index value is needed to detect bad Versym entries.
*
* entry:
* vnd - Address of verneed data
* vnd_num - # of Verneed entries
* versym - Information about versym section
*
* exit:
* If a non-zero vna_other field is seen, versym->gnu_needed is set.
*
* versym->max_verndx has been updated to contain the largest
* version index seen.
*/
static void
{
/*
* A non-zero value of vna_other indicates that this
* object references VERNEED items from the VERSYM
* array.
*/
}
/*
* Check any additional version dependencies.
*/
if (vcnt) {
continue;
}
}
}
}
/*
* Display version section information if the flags require it.
* Return version information needed by other output.
*
* entry:
* cache - Cache of all section headers
* shnum - # of sections in cache
* file - Name of file
* flags - Command line option flags
* versym - VERSYM_STATE block to be filled in.
*/
static void
{
/* Gather information about the version sections */
case SHT_DYNAMIC:
/*
* The GNU ld puts a DT_VERSYM entry in the dynamic
* section so that the runtime linker can use it to
* implement their versioning rules. They allow multiple
* incompatible functions with the same name to exist
* in different versions. The Solaris ld does not
* support this mechanism, and as such, does not
* produce DT_VERSYM. We use this fact to determine
* which ld produced this object, and how to interpret
* the version values.
*/
if ((shdr->sh_entsize == 0) ||
continue;
break;
}
break;
case SHT_SUNW_versym:
/* Record data address for later symbol processing */
continue;
}
break;
case SHT_SUNW_verdef:
case SHT_SUNW_verneed:
/*
* Ensure the data is non-NULL and the number
* of items is non-zero. Otherwise, we don't
* understand the section, and will not use it.
*/
continue;
}
continue;
}
/* Make sure the string table index is in range */
continue;
}
/*
* The section is usable. Save the cache entry.
*/
/*
* Under Solaris rules, if there is a verdef
* section, the max versym index is number
* of version definitions it supplies.
*/
} else {
}
break;
}
}
/*
* If there is a Verneed section, examine it for information
* related to GNU style versioning.
*/
if (verneed_cache != NULL)
/*
* Now that all the information is available, display the
* Verdef and Verneed section contents, if requested.
*/
if ((flags & FLG_SHOW_VERSIONS) == 0)
return;
if (verdef_cache != NULL) {
}
if (verneed_cache != NULL) {
/*
* If GNU versioning applies to this object, version_need()
* will update versym->max_verndx, and it is not
* necessary to call update_gnu_verndx().
*/
}
}
/*
* Search for and process any symbol tables.
*/
void
{
(osabi != ELFOSABI_SOLARIS)))
continue;
continue;
continue;
/*
* Loop through the symbol tables entries.
*/
}
}
/*
* Search for and process any SHT_SUNW_symsort or SHT_SUNW_tlssort sections.
* These sections are always associated with the .SUNW_ldynsym./.dynsym pair.
*/
static void
{
int output_cnt = 0;
continue;
continue;
/*
* If the section references a SUNW_ldynsym, then we
* expect to see the associated .dynsym immediately
* following. If it references a .dynsym, there is no
* SUNW_ldynsym. If it is any other type, then we don't
* know what to do with it.
*/
continue;
}
ldynsym_cnt = 0;
case SHT_SUNW_LDYNSYM:
continue;
/*
* We know that the dynsym follows immediately
* after the SUNW_ldynsym, and so, should be at
* (sortshdr->sh_link + 1). However, elfdump is a
* diagnostic tool, so we do the full paranoid
* search instead.
*/
break;
}
continue;
}
/* Fallthrough to process associated dynsym */
/* FALLTHROUGH */
case SHT_DYNSYM:
continue;
break;
default:
continue;
}
/*
* Output header
*/
if (ldynsym_cnt > 0) {
/*
* The data for .SUNW_ldynsym and dynsym sections
* is supposed to be adjacent with SUNW_ldynsym coming
* first. Check, and issue a warning if it isn't so.
*/
!= dynsym_state.sym) &&
((flags & FLG_CTL_FAKESHDR) == 0))
} else {
}
/* If not first one, insert a line of white space */
if (output_cnt++ > 0)
/*
* SUNW_dynsymsort and SUNW_dyntlssort are arrays of
* symbol indices. Iterate over the array entries,
* dispaying the referenced symbols.
*/
if (*ndx >= ldynsym_cnt) {
} else {
}
}
}
}
/*
* Search for and process any relocation sections.
*/
static void
{
void *rels;
continue;
continue;
/*
* Decide entry size.
*/
else
}
/*
* Determine the number of relocations available.
*/
continue;
}
continue;
/*
* Get the data buffer for the associated symbol table and
* string table.
*/
continue;
/*
* Loop through the relocation entries.
*/
const char *symname;
/*
* Unravel the relocation and determine the symbol with
* which this relocation is associated.
*/
} else {
}
/*
* A zero symbol index is only valid for a few
* relocations.
*/
if (symndx == 0) {
int badrel = 0;
(mach == EM_SPARC32PLUS) ||
(mach == EM_SPARCV9)) {
if ((reltype != R_SPARC_NONE) &&
(reltype != R_SPARC_REGISTER) &&
(reltype != R_SPARC_RELATIVE))
badrel++;
if ((reltype != R_386_NONE) &&
(reltype != R_386_RELATIVE))
badrel++;
if ((reltype != R_AMD64_NONE) &&
(reltype != R_AMD64_RELATIVE))
badrel++;
}
if (badrel) {
0, &inv_buf));
}
}
}
}
}
/*
* This value controls which test dyn_test() performs.
*/
/*
* Used by dynamic() to compare the value of a dynamic element against
* the starting address of the section it references.
*
* entry:
* test_type - Specify which dyn item is being tested.
* sh_type - SHT_* type value for required section.
* sec_cache - Cache entry for section, or NULL if the object lacks
* a section of this type.
* dyn - Dyn entry to be tested
* dynsec_cnt - # of dynamic section being examined. The first
* dynamic section is 1, the next is 2, and so on...
* ehdr - ELF header for file
* file - Name of file
*/
static void
{
/*
* These tests are based around the implicit assumption that
* there is only one dynamic section in an object, and also only
* one of the sections it references. We have therefore gathered
* all of the necessary information to test this in a single pass
* over the section headers, which is very efficient. We are not
* aware of any case where more than one dynamic section would
* be meaningful in an ELF object, so this is a reasonable solution.
*
* To test multiple dynamic sections correctly would be more
* expensive in code and time. We would have to build a data structure
* containing all the dynamic elements. Then, we would use the address
* to locate the section it references and ensure the section is of
* the right type and that the address in the dynamic element is
* to the start of the section. Then, we could check the size and
* entsize values against those same sections. This is O(n^2), and
* also complicated.
*
* In the highly unlikely case that there is more than one dynamic
* section, we only test the first one, and simply allow the values
* of the subsequent one to be displayed unchallenged.
*/
if (dynsec_cnt != 1)
return;
/*
* A DT_ item that references a section address should always find
* the section in the file.
*/
const char *name;
/*
* Supply section names instead of section types for
* things that reference progbits so that the error
* message will make more sense.
*/
case DT_INIT:
break;
case DT_FINI:
break;
default:
break;
}
CONV_FMT_ALT_CF, &buf2));
return;
}
switch (test_type) {
case DYN_TEST_ADDR:
/* The section address should match the DT_ item value */
break;
case DYN_TEST_SIZE:
/* The section size should match the DT_ item value */
break;
case DYN_TEST_ENTSIZE:
/* The sh_entsize value should match the DT_ item value */
break;
}
}
/*
* There are some DT_ entries that have corresponding symbols
* (e.g. DT_INIT and _init). It is expected that these items will
* both have the same value if both are present. This routine
* examines the well known symbol tables for such symbols and
* issues warnings for any that don't match.
*
* entry:
* dyn - Dyn entry to be tested
* symname - Name of symbol that corresponds to dyn
* symtab_cache, dynsym_cache, ldynsym_cache - Symbol tables to check
* target_cache - Section the symname section is expected to be
* associated with.
* cache - Cache of all section headers
* shnum - # of sections in cache
* ehdr - ELF header for file
* osabi - OSABI to apply when interpreting object
* file - Name of file
*/
static void
{
int i;
for (i = 0; i < 3; i++) {
switch (i) {
case 0:
break;
case 1:
break;
case 2:
break;
}
}
}
/*
* Search for and process a .dynamic section.
*/
static void
{
struct {
} sec;
int dynsec_cnt;
/*
* Make a pass over all the sections, gathering section information
* we'll need below.
*/
dynsec_num = 0;
case SHT_DYNAMIC:
if (dynsec_num == 0) {
dynsec_ndx = cnt;
/* Does it have a valid string table? */
}
dynsec_num++;
break;
case SHT_PROGBITS:
/*
* We want to detect the .init and .fini sections,
* if present. These are SHT_PROGBITS, so all we
* have to go on is the section name. Normally comparing
* names is a bad idea, but there are some special
* names (i.e. .init/.fini/.interp) that are very
* difficult to use in any other context, and for
* these symbols, we do the heuristic match.
*/
MSG_ORIG(MSG_ELF_INIT)) == 0) {
MSG_ORIG(MSG_ELF_FINI)) == 0) {
}
break;
case SHT_REL:
/*
* We want the SHT_REL section with the lowest
* offset. The linker gathers them together,
* and puts the address of the first one
* into the DT_REL dynamic element.
*/
break;
case SHT_RELA:
/* RELA is handled just like RELA above */
break;
/*
* The GRAB macro is used for the simple case in which
* we simply grab the first section of the desired type.
*/
case _sec_type: \
break
}
}
/*
* If no dynamic section, return immediately. If more than one
* dynamic section, then something odd is going on and an error
* is in order, but then continue on and display them all.
*/
if (dynsec_num == 0)
return;
if (dynsec_num > 1)
dynsec_cnt = 0;
cnt++) {
int dumped = 0;
continue;
dynsec_cnt++;
/*
* Verify the associated string table section.
*/
continue;
continue;
}
continue;
/*
* section with the lowest address. However, this is
* not true for dumped objects. Detect if this object has
* been dumped so that we can skip the reloc address test
* in that case.
*/
break;
}
}
Elf_dyn_title(0);
union {
} c_buf;
/*
* Print the information numerically, and if possible
* as a string. If a string is available, name is
* set to reference it.
*
* Also, take this opportunity to sanity check
* the values of DT elements. In the code above,
* we gathered information on sections that are
* referenced by the dynamic section. Here, we
* compare the attributes of those sections to
* the DT_ items that reference them and report
* on inconsistencies.
*
* Things not currently tested that could be improved
* in later revisions include:
* - We don't check PLT or GOT related items
* - We don't handle computing the lengths of
* relocation arrays. To handle this
* requires examining data that spans
* across sections, in a contiguous span
* within a single segment.
* - DT_VERDEFNUM and DT_VERNEEDNUM can't be
* verified without parsing the sections.
* - We don't handle DT_SUNW_SYMSZ, which would
* be the sum of the lengths of .dynsym and
* .SUNW_ldynsym
* - DT_SUNW_STRPAD can't be verified other than
* to check that it's not larger than
* the string table.
* - Some items come in "all or none" clusters
* that give an address, element size,
* and data length in bytes. We don't
* verify that there are no missing items
* in such groups.
*/
case DT_NULL:
/*
* Special case: DT_NULLs can come in groups
* that we prefer to reduce to a single line.
*/
dyn++;
end_ndx++;
}
continue;
/*
* String items all reference the dynstr. The string()
* function does the necessary sanity checking.
*/
case DT_NEEDED:
case DT_SONAME:
case DT_FILTER:
case DT_AUXILIARY:
case DT_CONFIG:
case DT_RPATH:
case DT_RUNPATH:
case DT_USED:
case DT_DEPAUDIT:
case DT_AUDIT:
break;
case DT_SUNW_AUXILIARY:
case DT_SUNW_FILTER:
if (osabi_solaris)
break;
case DT_FLAGS:
break;
case DT_FLAGS_1:
break;
case DT_POSFLAG_1:
break;
case DT_FEATURE_1:
break;
break;
case DT_SUNW_LDMACH:
if (!osabi_solaris)
break;
break;
/*
* Cases below this point are strictly sanity checking,
* and do not generate a name string. The TEST_ macros
* are used to hide the boiler plate arguments neeeded
* by dyn_test().
*/
case DT_FINI:
break;
case DT_FINI_ARRAY:
break;
case DT_FINI_ARRAYSZ:
break;
case DT_HASH:
break;
case DT_INIT:
break;
case DT_INIT_ARRAY:
break;
case DT_INIT_ARRAYSZ:
break;
case DT_MOVEENT:
break;
case DT_MOVESZ:
break;
case DT_MOVETAB:
break;
case DT_PREINIT_ARRAY:
break;
case DT_PREINIT_ARRAYSZ:
break;
case DT_REL:
if (!dumped)
break;
case DT_RELENT:
break;
case DT_RELA:
if (!dumped)
break;
case DT_RELAENT:
break;
case DT_STRTAB:
break;
case DT_STRSZ:
break;
case DT_SUNW_CAP:
if (osabi_solaris)
break;
case DT_SUNW_CAPINFO:
if (osabi_solaris)
break;
case DT_SUNW_CAPCHAIN:
if (osabi_solaris)
break;
case DT_SUNW_SYMTAB:
break;
case DT_SYMENT:
break;
case DT_SYMINENT:
break;
case DT_SYMINFO:
break;
case DT_SYMINSZ:
break;
case DT_SYMTAB:
break;
case DT_SUNW_SORTENT:
/*
* This entry is related to both the symsort and
* tlssort sections.
*/
if (osabi_solaris) {
int test_tls =
int test_sym =
!test_tls;
if (test_sym)
if (test_tls)
}
break;
case DT_SUNW_SYMSORT:
if (osabi_solaris)
break;
case DT_SUNW_SYMSORTSZ:
if (osabi_solaris)
break;
case DT_SUNW_TLSSORT:
if (osabi_solaris)
break;
case DT_SUNW_TLSSORTSZ:
if (osabi_solaris)
break;
case DT_VERDEF:
break;
case DT_VERNEED:
break;
case DT_VERSYM:
break;
}
}
}
}
/*
* Search for and process a MOVE section.
*/
static void
{
continue;
continue;
/*
* Determine the move data and number.
*/
continue;
}
continue;
/*
* Get the data buffer for the associated symbol table and
* string table.
*/
return;
const char *symname;
/*
* Check for null entries
*/
continue;
}
continue;
}
/*
* Additional sanity check.
*/
if (!((shndx == SHN_COMMON) ||
}
}
}
}
/*
* parse_note_t is used to track the state used by parse_note_entry()
* between calls, and also to return the results of each call.
*/
typedef struct {
/* pns_ fields track progress through the data */
/* pn_ fields return the results for a single call */
} parse_note_t;
/*
* Extract the various sub-parts of a note entry, and advance the
* data pointer past it.
*
* entry:
* The state pns_ fields contain current values for the Note section
*
* exit:
* On success, True (1) is returned, the state pns_ fields have been
* advanced to point at the start of the next entry, and the information
* for the recovered note entry is found in the state pn_ fields.
*
* On failure, False (0) is returned. The values contained in state
* are undefined.
*/
static int
{
/*
* Make sure we can at least reference the 3 initial entries
* (4-byte words) of the note information block.
*/
} else {
return (0);
}
/*
* Make sure any specified name string can be referenced.
*/
} else {
return (0);
}
}
/*
* Make sure any specified descriptor can be referenced.
*/
/*
* If namesz isn't a 4-byte multiple, account for any
* padding that must exist before the descriptor.
*/
}
} else {
return (0);
}
}
/* Name */
/* LINTED */
}
/*
* If multiple information blocks exist within a .note section
* account for any padding that must exist before the next
* information block.
*/
}
/* Data */
/* LINTED */
}
return (1);
}
/*
* Callback function for use with conv_str_to_c_literal() below.
*/
/*ARGSUSED2*/
static void
{
}
/*
* Traverse a note section analyzing each note information block.
* The data buffers size is used to validate references before they are made,
* and is decremented as each element is processed.
*/
void
{
int cnt = 0;
int is_corenote;
int do_swap;
/*
* Print out a single `note' information block.
*/
if (parse_note_entry(&pnstate) == 0)
return;
/*
* Is this a Solaris core note? Such notes all have
* the name "CORE".
*/
MSG_STR_CORE_SIZE + 1) == 0);
cnt++;
if (is_corenote)
else
/*
* The name string can contain embedded 'null'
* the final NULL is documented in the ELF ABI
* as being included in the namesz. So, display
* the name using C literal string notation, and
* include the terminating NULL in the output.
* We don't show surrounding double quotes, as
* that implies the termination that we are showing
* explicitly.
*/
}
/*
* If this is a core note, let the corenote()
* function handle it.
*/
if (is_corenote) {
/* We only issue the bad arch error once */
static int badnote_done = 0;
switch (corenote_ret) {
case CORENOTE_R_OK_DUMP:
hexdump = 1;
break;
case CORENOTE_R_OK:
hexdump = 0;
break;
case CORENOTE_R_BADDATA:
file);
break;
case CORENOTE_R_BADARCH:
if (badnote_done)
break;
file,
0, &inv_buf));
break;
case CORENOTE_R_BADTYPE:
file,
break;
}
}
/*
* The default thing when we don't understand
* the note data is to display it as hex bytes.
*/
if (hexdump) {
}
}
}
}
/*
* Search for and process .note sections.
*
* Returns the number of note sections seen.
*/
static Word
{
/*
* Otherwise look for any .note sections.
*/
continue;
note_cnt++;
continue;
/*
* As these sections are often hand rolled, make sure they're
* properly aligned before proceeding, and issue an error
* as necessary.
*
* Note that we will continue on to display the note even
* if it has bad alignment. We can do this safely, because
* libelf knows the alignment required for SHT_NOTE, and
* takes steps to deliver a properly aligned buffer to us
* even if the actual file is misaligned.
*/
continue;
/* LINTED */
}
return (note_cnt);
}
/*
* The Linux Standard Base defines a special note named .note.ABI-tag
* that is used to maintain Linux ABI information. Presence of this section
* is a strong indication that the object should be considered to be
* ELFOSABI_LINUX.
*
* This function returns True (1) if such a note is seen, and False (0)
* otherwise.
*/
static int
{
/*
* Section must be SHT_NOTE, must have the name
* .note.ABI-tag, and must have data.
*/
continue;
Word *w;
if (parse_note_entry(&pnstate) == 0)
break;
/*
* The type must be 1, and the name must be "GNU".
* The descsz must be at least 16 bytes.
*/
MSG_STR_CORE_SIZE + 1) != 0) ||
continue;
/*
* desc contains 4 32-bit fields. Field 0 must be 0,
* indicating Linux. The second, third, and fourth
* fields represent the earliest Linux kernel
* version compatible with this object.
*/
/*LINTED*/
if (*w == 0)
return (1);
}
}
return (0);
}
/*
* Determine an individual hash entry. This may be the initial hash entry,
* or an associated chain entry.
*/
static void
{
} else {
}
if (chain == 0) {
hashndx);
} else
/*
* Determine if this string is in the correct bucket.
*/
}
}
static void
{
continue;
/*
* Check the hash table data and size.
*/
continue;
}
continue;
}
/*
* The section holds the sizes in addition to the buckets and
* chains.
*/
continue;
}
/*
* Get the data buffer for the associated symbol table.
*/
continue;
}
continue;
continue;
}
continue;
}
/* LINTED */
/*
* Check that there is a chain for each symbol.
*/
continue;
}
/*
* Get the associated string table section.
*/
continue;
}
/*
* Loop through the hash buckets, printing the appropriate
* symbols.
*/
if (*hash == 0) {
count[0]++;
continue;
}
/*
* Each hash bucket must contain to a valid chain index.
* Because the symbol table is checked to be the same
* length as the chain array, this also implicitly
* checks those bounds.
*/
continue;
}
/*
* Determine if any other symbols are chained to this
* bucket.
*/
_cnt = 1;
while (_ndx) {
break;
}
_cnt++;
}
} else
}
break;
}
/*
* Print out the count information.
*/
continue;
}
if (cnt) {
bkts);
}
}
static void
{
const char *grpnam;
continue;
continue;
continue;
/*
* Get the data buffer for the associated symbol table and
* string table.
*/
return;
/*
* The first element of the group defines the group. The
* associated symbol is defined by the sh_link field.
*/
return;
}
if (grpdata[0] & GRP_COMDAT) {
}
}
/*
* The GNU assembler can use section symbols as the signature
* symbol as described by this comment in the gold linker
* (found via google):
*
* It seems that some versions of gas will create a
* section group associated with a section symbol, and
* then fail to give a name to the section symbol. In
* such a case, use the name of the section.
*
* In order to support such objects, we do the same.
*/
const char *name;
else
}
}
}
static void
{
char *gotdata;
/*
* First, find the got.
*/
MSG_ELF_GOT_SIZE) == 0) {
break;
}
}
return;
/*
* A got section within a relocatable object is suspicious.
*/
}
return;
}
/*
* Some architectures don't properly set the sh_entsize for the GOT
* table. If it's not set, default to a size of a pointer.
*/
return;
/* LINTED */
return;
}
/*
* Now we scan through all the sections looking for any relocations
* that may be against the GOT. Since these may not be isolated to a
* .rel[a].got section we check them all.
* While scanning sections save the symbol table entry (a symtab
* overriding a dynsym) so that we can lookup _GLOBAL_OFFSET_TABLE_.
*/
void *rels;
continue;
}
if (type == SHT_SYMTAB) {
continue;
}
continue;
/*
* Decide entry size.
*/
else
}
/*
* Determine the number of relocations available.
*/
continue;
}
continue;
/*
* Get the data buffer for the associated symbol table and
* string table.
*/
continue;
/*
* Loop through the relocation entries.
*/
/*
* Unravel the relocation.
*/
} else {
}
/*
* Only pay attention to relocations against the GOT.
*/
continue;
if ((gotshdr->sh_entsize == 0) ||
continue;
}
/* LINTED */
continue;
}
if (symndx)
}
}
else
gotsymaddr = gotbgn;
Elf_got_title(0);
/* LINTED */
else
/* LINTED */
}
}
void
{
}
/*
* This variable is used by regular() to communicate the address of
* the section header cache to sort_shdr_ndx_arr(). Unfortunately,
* the qsort() interface does not include a userdata argument by which
* such arbitrary data can be passed, so we are stuck using global data.
*/
/*
* Used with qsort() to sort the section indices so that they can be
* used to access the section headers in order of increasing data offset.
*
* entry:
* sort_shdr_ndx_arr_cache - Contains address of
* section header cache.
* v1, v2 - Point at elements of sort_shdr_bits array to be compared.
*
* exit:
* Returns -1 (less than), 0 (equal) or 1 (greater than).
*/
static int
{
return (-1);
return (1);
return (0);
}
static int
{
/*
* Obtain the .shstrtab data buffer to provide the required section
* name strings.
*/
/*
* It is rare, but legal, for an object to lack a
* header string table section.
*/
/*
* Allocate a cache to maintain a descriptor for each section.
*/
return (0);
}
*cache = cache_init;
_cache++;
/*
* Allocate an array that will hold the section index for
* each section that has data in the ELF file:
*
* - Is not a NOBITS section
* - Data has non-zero length
*
* Note that shnum is an upper bound on the size required. It
* is likely that we won't use a few of these array elements.
* Allocating a modest amount of extra memory in this case means
* that we can avoid an extra loop to count the number of needed
* items, and can fill this array immediately in the first loop
* below.
*/
return (0);
}
shdr_ndx_arr_cnt = 0;
/*
* Traverse the sections of the file. This gathering of data is
* carried out in two passes. First, the section headers are captured
* and the section header names are evaluated. A verification pass is
* then carried out over the section information. Files have been
* known to exhibit overlapping (and hence erroneous) section header
* information.
*
* Finally, the data for each section is obtained. This processing is
* carried out after section verification because should any section
* header overlap occur, and a file needs translating (ie. xlate'ing
* information from a non-native architecture file), then the process
* of translation can corrupt the section header information. Of
* course, if there is any section overlap, the data related to the
* sections is going to be compromised. However, it is the translation
* of this data that has caused problems with elfdump()'s ability to
* extract the data.
*/
}
/*
* If this section has data in the file, include it in
* the array of sections to check for address overlap.
*/
/*
* If a shstrtab exists, assign the section name.
*/
/* LINTED */
const char *symname;
char *secname;
/*
* A SUN naming convention employs a "%" within
* name. This originated from the compilers
* -xF option, that places functions into their
* own sections. This convention (which has no
* formal standard) has also been followed for
* COMDAT sections. To demangle the symbol
* name, the name must be separated from the
* section name.
*/
if (((flags & FLG_CTL_DEMANGLE) == 0) ||
else {
return (0);
}
}
continue;
}
/*
* Generate an error if the section name index is zero
* or exceeds the shstrtab data. Fall through to
* fabricate a section name.
*/
/* LINTED */
}
}
/*
* If there exists no shstrtab data, or a section header has no
* name (an invalid index of 0), then compose a name for the
* section.
*/
return (0);
}
}
/*
* Having collected all the sections, validate their address range.
* Cases have existed where the section information has been invalid.
* This can lead to all sorts of other, hard to diagnose errors, as
* each section is processed individually (ie. with elf_getdata()).
* Here, we carry out some address comparisons to catch a family of
* overlapping memory issues we have observed (likely, there are others
* that we have yet to discover).
*
* Note, should any memory overlap occur, obtaining any additional
* data from the file is questionable. However, it might still be
* possible to inspect the ELF header, Programs headers, or individual
* sections, so rather than bailing on an error condition, continue
* processing to see if any data can be salvaged.
*/
if (shdr_ndx_arr_cnt > 1) {
sizeof (*shdr_ndx_arr), sort_shdr_ndx_arr);
}
/*
* Check the section against all following ones, reporting
* any overlaps. Since we've sorted the sections by offset,
* we can stop after the first comparison that fails. There
* are no overlaps in a properly formed ELF file, in which
* case this algorithm runs in O(n) time. This will degenerate
* to O(n^2) for a completely broken file. Such a file is
* (1) highly unlikely, and (2) unusable, so it is reasonable
* for the analysis to take longer.
*/
} else { /* No overlap, so can stop */
break;
}
}
/*
* In addition to checking for sections overlapping
* each other (done above), we should also make sure
* the section doesn't overlap the section header array.
*/
}
}
/*
* Obtain the data for each section.
*/
}
/*
* If a string table, verify that it has NULL first and
* final bytes.
*/
if ((*s != '\0') ||
}
}
return (1);
}
/*
* Generate a cache of section headers and related information
* for use by the rest of elfdump. If requested (or the file
* contains no section headers), we generate a fake set of
* headers from the information accessible from the program headers.
* Otherwise, we use the real section headers contained in the file.
*/
static int
{
/*
* If there are no section headers, then resort to synthesizing
* section headers from the program headers. This is normally
* only done by explicit request, but in this case there's no
* reason not to go ahead, since the alternative is simply to quit.
*/
*flags |= FLG_CTL_FAKESHDR;
}
if (*flags & FLG_CTL_FAKESHDR) {
return (0);
} else {
return (0);
}
return (1);
}
int
{
int ret = 0;
int addr_align;
return (ret);
}
return (ret);
}
return (ret);
}
return (ret);
}
/*
* If the user requested section headers derived from the
* program headers (-P option) and this file doesn't have
* any program headers (i.e. ET_REL), then we can't do it.
*/
return (ret);
}
return (ret);
}
} else
/*
* Print the elf header.
*/
if (flags & FLG_SHOW_EHDR)
/*
* If the section headers or program headers have inadequate
* alignment for the class of object, print a warning. libelf
* can handle such files, but programs that use them can crash
* when they dereference unaligned items.
*
* Note that the AMD64 ABI, although it is a 64-bit architecture,
* allows access to data types smaller than 128-bits to be on
* word alignment.
*/
addr_align = sizeof (Word);
else
addr_align = sizeof (Addr);
/*
* Determine the Operating System ABI (osabi) we will use to
* interpret the object.
*/
if (flags & FLG_CTL_OSABI) {
/*
* If the user explicitly specifies '-O none', we need
* to display a completely generic view of the file.
* However, libconv is written to assume that ELFOSABI_NONE
* is equivalent to ELFOSABI_SOLARIS. To get the desired
* effect, we use an osabi that libconv has no knowledge of.
*/
if (osabi == ELFOSABI_NONE)
} else {
/* Determine osabi from file */
if (osabi == ELFOSABI_NONE) {
/*
*
* Ideally, we wait to create the section header cache
* until after the program headers are printed. If we
* only output program headers, we can skip building
* the cache entirely.
*
* Proper interpretation of program headers requires
* the osabi, which is supposed to be in the ELF header.
* However, many systems (Solaris and Linux included)
* have a history of setting the osabi to the generic
* SysV ABI (ELFOSABI_NONE). We assume ELFOSABI_SOLARIS
* in such cases, but would like to check the object
* to see if it has a Linux .note.ABI-tag section,
* which implies ELFOSABI_LINUX. This requires a
* section header cache.
*
* To break the cycle, we create section headers now
* if osabi is ELFOSABI_NONE, and later otherwise.
* If it succeeds, we use them, if not, we defer
* exiting until after the program headers are out.
*/
} else {
0, &ibuf2));
}
}
}
/*
* We treat ELFOSABI_NONE identically to ELFOSABI_SOLARIS.
* Mapping NONE to SOLARIS simplifies the required test.
*/
if (osabi == ELFOSABI_NONE)
}
/*
* Print the program headers.
*/
return (ret);
}
continue;
}
}
/*
* If we have flag bits set that explicitly require a show or calc
* operation, but none of them require the section headers, then
* we are done and can return now.
*/
return (ret);
/*
* Everything from this point on requires section headers.
* If we have no section headers, there is no reason to continue.
*
* If we tried above to create the section header cache and failed,
* it is time to exit. Otherwise, create it if needed.
*/
switch (cache_state) {
case CACHE_NEEDED:
return (ret);
break;
case CACHE_OK:
break;
case CACHE_FAIL:
return (ret);
}
if (shnum <= 1)
goto done;
/*
* If -w was specified, find and write out the section(s) data.
*/
if (wfd) {
/*
* Return an exit status of 1, because
* the failure is not related to the
* ELF file, but by system resources.
*/
ret = 1;
goto done;
}
}
}
}
/*
* If we have no flag bits set that explicitly require a show or calc
* operation, but match options (-I, -N, -T) were used, then run
* through the section headers and see if we can't deduce show flags
* from the match options given.
*
* We don't do this if -w was specified, because (-I, -N, -T) used
* with -w in lieu of some other option is supposed to be quiet.
*/
continue;
case SHT_PROGBITS:
/*
* Heuristic time: It is usually bad form
* section based on its name. However, there
* are ABI mandated exceptions. Check for
* these special names.
*/
/* The ELF ABI specifies .interp and .got */
MSG_ORIG(MSG_ELF_INTERP)) == 0) {
flags |= FLG_SHOW_INTERP;
break;
}
MSG_ORIG(MSG_ELF_GOT)) == 0) {
flags |= FLG_SHOW_GOT;
break;
}
/*
* The GNU compilers, and amd64 ABI, define
* .eh_frame and .eh_frame_hdr. The Sun
* C++ ABI defines .exception_ranges.
*/
MSG_SCN_FRM_SIZE) == 0) ||
MSG_SCN_EXRANGE_SIZE) == 0)) {
flags |= FLG_SHOW_UNWIND;
break;
}
break;
case SHT_SYMTAB:
case SHT_DYNSYM:
case SHT_SUNW_LDYNSYM:
case SHT_SUNW_versym:
case SHT_SYMTAB_SHNDX:
break;
case SHT_RELA:
case SHT_REL:
flags |= FLG_SHOW_RELOC;
break;
case SHT_HASH:
flags |= FLG_SHOW_HASH;
break;
case SHT_DYNAMIC:
break;
case SHT_NOTE:
flags |= FLG_SHOW_NOTE;
break;
case SHT_GROUP:
flags |= FLG_SHOW_GROUP;
break;
case SHT_SUNW_symsort:
case SHT_SUNW_tlssort:
flags |= FLG_SHOW_SORT;
break;
case SHT_SUNW_cap:
flags |= FLG_SHOW_CAP;
break;
case SHT_SUNW_move:
flags |= FLG_SHOW_MOVE;
break;
case SHT_SUNW_syminfo:
break;
case SHT_SUNW_verdef:
case SHT_SUNW_verneed:
break;
case SHT_AMD64_UNWIND:
flags |= FLG_SHOW_UNWIND;
break;
}
}
}
if (flags & FLG_SHOW_SHDR)
if (flags & FLG_SHOW_INTERP)
if (flags & FLG_SHOW_SYMBOLS)
if (flags & FLG_SHOW_HASH)
if (flags & FLG_SHOW_GOT)
if (flags & FLG_SHOW_GROUP)
if (flags & FLG_SHOW_SYMINFO)
if (flags & FLG_SHOW_RELOC)
if (flags & FLG_SHOW_DYNAMIC)
if (flags & FLG_SHOW_NOTE) {
/*
* Solaris core files have section headers, but these
* headers do not include SHT_NOTE sections that reference
* the core note sections. This means that note() won't
* find the core notes. Fake section headers (-P option)
* recover these sections, but it is inconvenient to require
* users to specify -P in this situation. If the following
* are all true:
*
* - No note sections were found
* - This is a core file
* - We are not already using fake section headers
*
* then we will automatically generate fake section headers
* and then process them in a second call to note().
*/
!(flags & FLG_CTL_FAKESHDR) &&
¬e_cache, ¬e_shnum) != 0)) {
}
}
if (flags & FLG_CALC_CHECKSUM)
if ((flags & FLG_SHOW_UNWIND) &&
/* Release the memory used to cache section headers */
done:
if (flags & FLG_CTL_FAKESHDR)
else
return (ret);
}