mirror of
https://github.com/serge1/ELFIO.git
synced 2024-12-28 15:15:04 +00:00
331 lines
8.9 KiB
C++
331 lines
8.9 KiB
C++
/*
|
|
ELFDump.cpp - Dump ELF file using ELFIO library.
|
|
|
|
Copyright (C) 2001-2011 by Serge Lamikhov-Center
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
*/
|
|
|
|
#ifdef _MSC_VER
|
|
#define _SCL_SECURE_NO_WARNINGS
|
|
#define ELFIO_NO_INTTYPES
|
|
#endif
|
|
|
|
#define PRIx64 "llx"
|
|
|
|
#define __STDC_FORMAT_MACROS
|
|
|
|
#include <string>
|
|
#include <elfio.hpp>
|
|
|
|
using namespace std;
|
|
using namespace ELFIO;
|
|
|
|
void
|
|
PrintHeader( const elfio& reader )
|
|
{
|
|
printf( "ELF Header\n" );
|
|
printf( " Class: %s (%d)\n",
|
|
( ELFCLASS32 == reader.get_class() ) ? "ELF32" : "ELF64",
|
|
(int)reader.get_class() );
|
|
if ( ELFDATA2LSB == reader.get_encoding() ) {
|
|
printf( " Encoding: Little endian\n" );
|
|
}
|
|
else if ( ELFDATA2MSB == reader.get_encoding() ) {
|
|
printf( " Encoding: Big endian\n" );
|
|
}
|
|
else {
|
|
printf( " Encoding: Unknown\n" );
|
|
}
|
|
printf( " ELFVersion: %s (%d)\n",
|
|
( EV_CURRENT == reader.get_elf_version() ) ? "Current" : "Unknown",
|
|
(int)reader.get_elf_version() );
|
|
printf( " Type: 0x%04X\n", reader.get_type() );
|
|
printf( " Machine: 0x%04X\n", reader.get_machine() );
|
|
printf( " Version: 0x%08X\n", reader.get_version() );
|
|
printf( " Entry: 0x%08" PRIx64 "\n", reader.get_entry() );
|
|
printf( " Flags: 0x%08X\n\n", reader.get_flags() );
|
|
}
|
|
|
|
|
|
string
|
|
SectionTypes( Elf_Word type )
|
|
{
|
|
string sRet = "UNKNOWN";
|
|
switch ( type ) {
|
|
case SHT_NULL :
|
|
sRet = "NULL";
|
|
break;
|
|
case SHT_PROGBITS :
|
|
sRet = "PROGBITS";
|
|
break;
|
|
case SHT_SYMTAB :
|
|
sRet = "SYMTAB";
|
|
break;
|
|
case SHT_STRTAB :
|
|
sRet = "STRTAB";
|
|
break;
|
|
case SHT_RELA :
|
|
sRet = "RELA";
|
|
break;
|
|
case SHT_HASH :
|
|
sRet = "HASH";
|
|
break;
|
|
case SHT_DYNAMIC :
|
|
sRet = "DYNAMIC";
|
|
break;
|
|
case SHT_NOTE :
|
|
sRet = "NOTE";
|
|
break;
|
|
case SHT_NOBITS :
|
|
sRet = "NOBITS";
|
|
break;
|
|
case SHT_REL :
|
|
sRet = "REL";
|
|
break;
|
|
case SHT_SHLIB :
|
|
sRet = "SHLIB";
|
|
break;
|
|
case SHT_DYNSYM :
|
|
sRet = "DYNSYM";
|
|
break;
|
|
case SHT_INIT_ARRAY :
|
|
sRet = "SHT_INIT_ARRAY";
|
|
break;
|
|
case SHT_FINI_ARRAY :
|
|
sRet = "SHT_FINI_ARRAY";
|
|
break;
|
|
case SHT_PREINIT_ARRAY :
|
|
sRet = "SHT_PREINIT_ARRAY";
|
|
break;
|
|
case SHT_GROUP :
|
|
sRet = "SHT_GROUP";
|
|
break;
|
|
case SHT_SYMTAB_SHNDX :
|
|
sRet = "SHT_SYMTAB_SHNDX";
|
|
break;
|
|
}
|
|
|
|
return sRet;
|
|
}
|
|
|
|
|
|
string SectionFlags( Elf_Xword flags )
|
|
{
|
|
string sRet = "";
|
|
if ( flags & SHF_WRITE ) {
|
|
sRet += "W";
|
|
}
|
|
if ( flags & SHF_ALLOC ) {
|
|
sRet += "A";
|
|
}
|
|
if ( flags & SHF_EXECINSTR ) {
|
|
sRet += "X";
|
|
}
|
|
|
|
return sRet;
|
|
}
|
|
|
|
|
|
void
|
|
PrintSection( int i, const section* sec )
|
|
{
|
|
Elf64_Addr addr = sec->get_address();
|
|
Elf_Xword size = sec->get_size();
|
|
PRIx64;
|
|
printf( " [%2x] %-20s %-8.8s %08"PRIx64" %06"PRIx64" %02"PRIx64" %-3.3s %02x %04x %02"PRIx64"\n",
|
|
i,
|
|
string( sec->get_name() ).substr( 0, 20 ).c_str(),
|
|
SectionTypes( sec->get_type() ).c_str(),
|
|
sec->get_address(),
|
|
sec->get_size(),
|
|
sec->get_entry_size(),
|
|
SectionFlags( sec->get_flags() ).c_str(),
|
|
sec->get_link(),
|
|
sec->get_info(),
|
|
sec->get_addr_align() );
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
string
|
|
SegmentTypes( Elf_Word type )
|
|
{
|
|
string sRet = "UNKNOWN";
|
|
switch ( type ) {
|
|
case PT_NULL:
|
|
sRet = "NULL";
|
|
break;
|
|
case PT_LOAD:
|
|
sRet = "PT_LOAD";
|
|
break;
|
|
case PT_DYNAMIC:
|
|
sRet = "PT_DYNAMIC";
|
|
break;
|
|
case PT_INTERP:
|
|
sRet = "PT_INTERP";
|
|
break;
|
|
case PT_NOTE:
|
|
sRet = "PT_NOTE";
|
|
break;
|
|
case PT_SHLIB:
|
|
sRet = "PT_SHLIB";
|
|
break;
|
|
case PT_PHDR:
|
|
sRet = "PT_PHDR";
|
|
break;
|
|
case PT_TLS:
|
|
sRet = "PT_TLS";
|
|
break;
|
|
}
|
|
|
|
return sRet;
|
|
}
|
|
|
|
|
|
void
|
|
PrintSegment( int i, const segment* seg )
|
|
{
|
|
printf( " [%2x] %-10.10s %08"PRIx64" %08"PRIx64" %08"PRIx64" %08"PRIx64" %08x %08"PRIx64"\n",
|
|
i,
|
|
SegmentTypes( seg->get_type() ).c_str(),
|
|
seg->get_virtual_address(),
|
|
seg->get_physical_address(),
|
|
seg->get_file_size(),
|
|
seg->get_memory_size(),
|
|
seg->get_flags(),
|
|
seg->get_align() );
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void
|
|
PrintSymbol( std::string& name, Elf64_Addr value,
|
|
Elf_Xword size,
|
|
unsigned char bind, unsigned char type,
|
|
Elf_Half section )
|
|
{
|
|
printf( "%-46.46s %08"PRIx64" %08"PRIx64" %01x %01x %02x\n",
|
|
name.c_str(),
|
|
value,
|
|
size,
|
|
(int)bind,
|
|
(int)type,
|
|
section );
|
|
}
|
|
|
|
|
|
int main( int argc, char** argv )
|
|
{
|
|
if ( argc != 2 ) {
|
|
printf( "Usage: ELFDump <file_name>\n" );
|
|
return 1;
|
|
}
|
|
|
|
|
|
// Open ELF reader
|
|
elfio reader;
|
|
|
|
if ( !reader.load( argv[1] ) ) {
|
|
printf( "File %s is not found or it is not an ELF file\n", argv[1] );
|
|
return 1;
|
|
}
|
|
|
|
// Print ELF file header
|
|
PrintHeader( reader );
|
|
|
|
// Print ELF file sections
|
|
printf( "Section headers:\n" );
|
|
printf( " [Nr] Name Type Addr Size ES Flg Lk Inf Al\n" );
|
|
int nSecNo = reader.sections.size();
|
|
int i;
|
|
for ( i = 0; i < nSecNo; ++i ) { // For all sections
|
|
section* sec = reader.sections[i];
|
|
PrintSection( i, sec );
|
|
}
|
|
printf( "Key to Flags: W (write), A (alloc), X (execute)\n\n" );
|
|
|
|
// Print ELF file segments
|
|
int nSegNo = reader.segments.size();
|
|
if ( nSegNo > 0 ) {
|
|
printf( "Segment headers:\n" );
|
|
printf( " [Nr] Type VirtAddr PhysAddr FileSize Mem.Size Flags Align\n" );
|
|
}
|
|
for ( i = 0; i < nSegNo; ++i ) { // For all sections
|
|
segment* seg = reader.segments[i];
|
|
PrintSegment( i, seg );
|
|
}
|
|
printf( "\n" );
|
|
|
|
// Print symbol tables
|
|
nSecNo = reader.sections.size();
|
|
for ( i = 0; i < nSecNo; ++i ) { // For all sections
|
|
section* sec = reader.sections[i];
|
|
if ( SHT_SYMTAB == sec->get_type() || SHT_DYNSYM == sec->get_type() ) {
|
|
symbol_section_accessor symbols( reader, sec );
|
|
|
|
std::string name;
|
|
Elf64_Addr value;
|
|
Elf_Xword size;
|
|
unsigned char bind;
|
|
unsigned char type;
|
|
Elf_Half section;
|
|
unsigned char other;
|
|
Elf_Xword nSymNo = symbols.get_symbols_num();
|
|
if ( 0 < nSymNo ) {
|
|
printf( "Symbol table (%s)\n", sec->get_name().c_str() );
|
|
printf( " Name Value Size Bind Type Sect\n" );
|
|
for ( int i = 0; i < nSymNo; ++i ) {
|
|
symbols.get_symbol( i, name, value, size, bind, type, section, other );
|
|
PrintSymbol( name, value, size, bind, type, section );
|
|
}
|
|
}
|
|
|
|
printf( "\n" );
|
|
}
|
|
}
|
|
|
|
for ( i = 0; i < nSecNo; ++i ) { // For all sections
|
|
section* sec = reader.sections[i];
|
|
if ( SHT_NOTE == sec->get_type() ) {
|
|
note_section_accessor notes( reader, sec );
|
|
int nNotesNo = notes.get_notes_num();
|
|
if ( 0 < nNotesNo ) {
|
|
printf( "Note section (%s)\n", sec->get_name().c_str() );
|
|
printf( " No Type Name\n" );
|
|
for ( int i = 0; i < nNotesNo; ++i ) { // For all notes
|
|
Elf_Word type;
|
|
std::string name;
|
|
void* desc;
|
|
Elf_Word descsz;
|
|
|
|
notes.get_note( i, type, name, desc, descsz );
|
|
printf( " [%2d] 0x%08x %s\n", i, type, name.c_str() );
|
|
}
|
|
}
|
|
|
|
printf( "\n" );
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|