mirror/ELFIO
1
0
Fork 0
mirror of https://github.com/serge1/ELFIO.git synced 2025-02-06 12:39:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reformat sources by using clang-format

Browse Source 
It is not perfect (and, probably, it is worser than it was before), but, it is automatic
This commit is contained in:
Serge Lamikhov-Center 2020-08-21 07:56:08 -07:00
parent 46acd5c16d
commit 9c739b49a0
20 changed files with 3011 additions and 3216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
.clang-format
View File

@ -1,27 +1,34 @@
{
BasedOnStyle : LLVM,
BasedOnStyle : LLVM
AlignConsecutiveAssignments : true,
AlignConsecutiveDeclarations : true,
AlignConsecutiveMacros : true,
AlignEscapedNewlines : true,
AlignOperands : true,
AlignTrailingComments : true,
UseTab : Never,
IndentWidth : 4,
TabWidth : 4,
BreakBeforeBraces : Stroustrup,
AllowShortIfStatementsOnASingleLine : false,
IndentCaseLabels : false,
ColumnLimit : 90,
AccessModifierOffset : -4,
NamespaceIndentation : Inner,
PointerAlignment : Left,
FixNamespaceComments : true,
SortIncludes : false,
ReflowComments : false,
SpacesInConditionalStatement : true,
SpacesInParentheses : true,
}
AccessModifierOffset : -2
AlignAfterOpenBracket : true
AlignConsecutiveAssignments : true
AlignConsecutiveDeclarations : true
AlignConsecutiveMacros : true
AlignEscapedNewlines : true
AlignOperands : true
AlignTrailingComments : true
BinPackParameters : false
BraceWrapping:
AfterCaseLabel : true
AfterClass : true
AfterEnum : true
AfterFunction : true
AfterNamespace : false
AfterStruct : true
AfterExternBlock : true
BeforeCatch : true
BeforeElse : true
BreakBeforeBraces : Custom
ColumnLimit : 80
FixNamespaceComments : true
IndentCaseLabels : false
IndentWidth : 4
NamespaceIndentation : Inner
PointerAlignment : Left
ReflowComments : false
SortIncludes : false
SpacesInConditionalStatement : true
SpacesInParentheses : true
TabWidth : 4
UseTab : Never

134
elfio/elf_types.hpp
View File

@ -24,25 +24,25 @@ THE SOFTWARE.
#define ELFTYPES_H
#ifndef ELFIO_NO_OWN_TYPES
#if !defined(ELFIO_NO_CSTDINT) && !defined(ELFIO_NO_INTTYPES)
#include <stdint.h>
#else
typedef unsigned char uint8_t;
typedef signed char int8_t;
typedef unsigned short uint16_t;
typedef signed short int16_t;
#ifdef _MSC_VER
typedef unsigned __int32 uint32_t;
typedef signed __int32 int32_t;
typedef unsigned __int64 uint64_t;
typedef signed __int64 int64_t;
#else
typedef unsigned int uint32_t;
typedef signed int int32_t;
typedef unsigned long long uint64_t;
typedef signed long long int64_t;
#endif // _MSC_VER
#endif // ELFIO_NO_CSTDINT
#if !defined( ELFIO_NO_CSTDINT ) && !defined( ELFIO_NO_INTTYPES )
#include <stdint.h>
#else
typedef unsigned char uint8_t;
typedef signed char int8_t;
typedef unsigned short uint16_t;
typedef signed short int16_t;
#ifdef _MSC_VER
typedef unsigned __int32 uint32_t;
typedef signed __int32 int32_t;
typedef unsigned __int64 uint64_t;
typedef signed __int64 int64_t;
#else
typedef unsigned int uint32_t;
typedef signed int int32_t;
typedef unsigned long long uint64_t;
typedef signed long long int64_t;
#endif // _MSC_VER
#endif // ELFIO_NO_CSTDINT
#endif // ELFIO_NO_OWN_TYPES
namespace ELFIO {
@ -80,7 +80,6 @@ typedef uint64_t Elf64_Off;
#define ET_LOPROC 0xFF00
#define ET_HIPROC 0xFFFF
#define EM_NONE 0 // No machine
#define EM_M32 1 // AT&T WE 32100
#define EM_SPARC 2 // SUN SPARC
@ -91,7 +90,8 @@ typedef uint64_t Elf64_Off;
#define EM_860 7 // Intel 80860
#define EM_MIPS 8 // MIPS R3000 (officially, big-endian only)
#define EM_S370 9 // IBM System/370
#define EM_MIPS_RS3_LE 10 // MIPS R3000 little-endian (Oct 4 1999 Draft) Deprecated
#define EM_MIPS_RS3_LE \
10 // MIPS R3000 little-endian (Oct 4 1999 Draft) Deprecated
#define EM_res011 11 // Reserved
#define EM_res012 12 // Reserved
#define EM_res013 13 // Reserved
@ -192,7 +192,8 @@ typedef uint64_t Elf64_Off;
#define EM_SE_C33 107 // S1C33 Family of Seiko Epson processors
#define EM_SEP 108 // Sharp embedded microprocessor
#define EM_ARCA 109 // Arca RISC Microprocessor
#define EM_UNICORE 110 // Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University
#define EM_UNICORE \
110 // Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University
#define EM_EXCESS 111 // eXcess: 16/32/64-bit configurable embedded CPU
#define EM_DXP 112 // Icera Semiconductor Inc. Deep Execution Processor
#define EM_ALTERA_NIOS2 113 // Altera Nios II soft-core processor
@ -200,7 +201,8 @@ typedef uint64_t Elf64_Off;
#define EM_XGATE 115 // Motorola XGATE embedded processor
#define EM_C166 116 // Infineon C16x/XC16x processor
#define EM_M16C 117 // Renesas M16C series microprocessors
#define EM_DSPIC30F 118 // Microchip Technology dsPIC30F Digital Signal Controller
#define EM_DSPIC30F \
118 // Microchip Technology dsPIC30F Digital Signal Controller
#define EM_CE 119 // Freescale Communication Engine RISC core
#define EM_M32C 120 // Renesas M32C series microprocessors
#define EM_res121 121 // Reserved
@ -250,7 +252,8 @@ typedef uint64_t Elf64_Off;
#define EM_QDSP6 164 // QUALCOMM DSP6 Processor
#define EM_8051 165 // Intel 8051 and variants
#define EM_STXP7X 166 // STMicroelectronics STxP7x family
#define EM_NDS32 167 // Andes Technology compact code size embedded RISC processor family
#define EM_NDS32 \
167 // Andes Technology compact code size embedded RISC processor family
#define EM_ECOG1 168 // Cyan Technology eCOG1X family
#define EM_ECOG1X 168 // Cyan Technology eCOG1X family
#define EM_MAXQ30 169 // Dallas Semiconductor MAXQ30 Core Micro-controllers
@ -369,17 +372,20 @@ typedef uint64_t Elf64_Off;
#define ELFOSABI_AROS 15 // Amiga Research OS
#define ELFOSABI_FENIXOS 16 // The FenixOS highly scalable multi-core OS
// 64-255 Architecture-specific value range
#define ELFOSABI_AMDGPU_HSA 64 // AMDGPU OS for HSA compatible compute
#define ELFOSABI_AMDGPU_HSA \
64 // AMDGPU OS for HSA compatible compute \
// kernels.
#define ELFOSABI_AMDGPU_PAL 65 // AMDGPU OS for AMD PAL compatible graphics
#define ELFOSABI_AMDGPU_PAL \
65 // AMDGPU OS for AMD PAL compatible graphics \
// shaders and compute kernels.
#define ELFOSABI_AMDGPU_MESA3D 66 // AMDGPU OS for Mesa3D compatible graphics
#define ELFOSABI_AMDGPU_MESA3D \
66 // AMDGPU OS for Mesa3D compatible graphics \
// shaders and compute kernels.
// AMDGPU specific e_flags
#define EF_AMDGPU_MACH 0x0ff // AMDGPU processor selection mask.
#define EF_AMDGPU_XNACK 0x100 // Indicates if the XNACK target feature is
#define EF_AMDGPU_XNACK \
0x100 // Indicates if the XNACK target feature is \
// enabled for all code contained in the ELF.
// AMDGPU processors
#define EF_AMDGPU_MACH_NONE 0x000 // Unspecified processor.
@ -685,9 +691,9 @@ typedef uint64_t Elf64_Off;
#define DF_BIND_NOW 0x8
#define DF_STATIC_TLS 0x10
// ELF file header
struct Elf32_Ehdr {
struct Elf32_Ehdr
{
unsigned char e_ident[EI_NIDENT];
Elf_Half e_type;
Elf_Half e_machine;
@ -704,7 +710,8 @@ struct Elf32_Ehdr {
Elf_Half e_shstrndx;
};
struct Elf64_Ehdr {
struct Elf64_Ehdr
{
unsigned char e_ident[EI_NIDENT];
Elf_Half e_type;
Elf_Half e_machine;
@ -721,9 +728,9 @@ struct Elf64_Ehdr {
Elf_Half e_shstrndx;
};
// Section header
struct Elf32_Shdr {
struct Elf32_Shdr
{
Elf_Word sh_name;
Elf_Word sh_type;
Elf_Word sh_flags;
@ -736,7 +743,8 @@ struct Elf32_Shdr {
Elf_Word sh_entsize;
};
struct Elf64_Shdr {
struct Elf64_Shdr
{
Elf_Word sh_name;
Elf_Word sh_type;
Elf_Xword sh_flags;
@ -749,9 +757,9 @@ struct Elf64_Shdr {
Elf_Xword sh_entsize;
};
// Segment header
struct Elf32_Phdr {
struct Elf32_Phdr
{
Elf_Word p_type;
Elf32_Off p_offset;
Elf32_Addr p_vaddr;
@ -762,7 +770,8 @@ struct Elf32_Phdr {
Elf_Word p_align;
};
struct Elf64_Phdr {
struct Elf64_Phdr
{
Elf_Word p_type;
Elf_Word p_flags;
Elf64_Off p_offset;
@ -773,9 +782,9 @@ struct Elf64_Phdr {
Elf_Xword p_align;
};
// Symbol table entry
struct Elf32_Sym {
struct Elf32_Sym
{
Elf_Word st_name;
Elf32_Addr st_value;
Elf_Word st_size;
@ -784,7 +793,8 @@ struct Elf32_Sym {
Elf_Half st_shndx;
};
struct Elf64_Sym {
struct Elf64_Sym
{
Elf_Word st_name;
unsigned char st_info;
unsigned char st_other;
@ -793,48 +803,51 @@ struct Elf64_Sym {
Elf_Xword st_size;
};
#define ELF_ST_BIND( i ) ( ( i ) >> 4 )
#define ELF_ST_TYPE( i ) ( (i)&0xf )
#define ELF_ST_INFO( b, t ) ( ( ( b ) << 4 ) + ( (t)&0xf ) )
#define ELF_ST_BIND(i) ((i)>>4)
#define ELF_ST_TYPE(i) ((i)&0xf)
#define ELF_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
#define ELF_ST_VISIBILITY(o) ((o)&0x3)
#define ELF_ST_VISIBILITY( o ) ( (o)&0x3 )
// Relocation entries
struct Elf32_Rel {
struct Elf32_Rel
{
Elf32_Addr r_offset;
Elf_Word r_info;
};
struct Elf32_Rela {
struct Elf32_Rela
{
Elf32_Addr r_offset;
Elf_Word r_info;
Elf_Sword r_addend;
};
struct Elf64_Rel {
struct Elf64_Rel
{
Elf64_Addr r_offset;
Elf_Xword r_info;
};
struct Elf64_Rela {
struct Elf64_Rela
{
Elf64_Addr r_offset;
Elf_Xword r_info;
Elf_Sxword r_addend;
};
#define ELF32_R_SYM( i ) ( ( i ) >> 8 )
#define ELF32_R_TYPE( i ) ( (unsigned char)( i ) )
#define ELF32_R_INFO( s, t ) ( ( ( s ) << 8 ) + (unsigned char)( t ) )
#define ELF32_R_SYM(i) ((i)>>8)
#define ELF32_R_TYPE(i) ((unsigned char)(i))
#define ELF32_R_INFO(s,t) (((s)<<8 )+(unsigned char)(t))
#define ELF64_R_SYM(i) ((i)>>32)
#define ELF64_R_TYPE(i) ((i)&0xffffffffL)
#define ELF64_R_INFO(s,t) ((((int64_t)(s))<<32)+((t)&0xffffffffL))
#define ELF64_R_SYM( i ) ( ( i ) >> 32 )
#define ELF64_R_TYPE( i ) ( (i)&0xffffffffL )
#define ELF64_R_INFO( s, t ) \
( ( ( ( int64_t )( s ) ) << 32 ) + ( (t)&0xffffffffL ) )
// Dynamic structure
struct Elf32_Dyn {
struct Elf32_Dyn
{
Elf_Sword d_tag;
union {
Elf_Word d_val;
@ -842,7 +855,8 @@ struct Elf32_Dyn {
} d_un;
};
struct Elf64_Dyn {
struct Elf64_Dyn
{
Elf_Sxword d_tag;
union {
Elf_Xword d_val;

445
elfio/elfio.hpp
View File

@ -24,10 +24,10 @@ THE SOFTWARE.
#define ELFIO_HPP
#ifdef _MSC_VER
#pragma warning ( push )
#pragma warning(disable:4996)
#pragma warning(disable:4355)
#pragma warning(disable:4244)
#pragma warning( push )
#pragma warning( disable : 4996 )
#pragma warning( disable : 4355 )
#pragma warning( disable : 4244 )
#endif
#include <string>
@ -47,25 +47,19 @@ THE SOFTWARE.
#include <elfio/elfio_strings.hpp>
#define ELFIO_HEADER_ACCESS_GET( TYPE, FNAME ) \
TYPE \
get_##FNAME() const \
{ \
return header ? (header->get_##FNAME()) : 0; \
}
TYPE get_##FNAME() const { return header ? ( header->get_##FNAME() ) : 0; }
#define ELFIO_HEADER_ACCESS_GET_SET( TYPE, FNAME ) \
TYPE \
get_##FNAME() const \
{ \
return header ? (header->get_##FNAME()) : 0; \
} \
void \
set_##FNAME( TYPE val ) \
{ \
if (header) { \
TYPE get_##FNAME() const \
{ \
return header ? ( header->get_##FNAME() ) : 0; \
} \
void set_##FNAME( TYPE val ) \
{ \
if ( header ) { \
header->set_##FNAME( val ); \
} \
} \
}
namespace ELFIO {
@ -73,7 +67,7 @@ namespace ELFIO {
class elfio
{
public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
elfio() : sections( this ), segments( this )
{
header = 0;
@ -81,13 +75,10 @@ class elfio
create( ELFCLASS32, ELFDATA2LSB );
}
//------------------------------------------------------------------------------
~elfio()
{
clean();
}
//------------------------------------------------------------------------------
~elfio() { clean(); }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void create( unsigned char file_class, unsigned char encoding )
{
clean();
@ -96,7 +87,7 @@ class elfio
create_mandatory_sections();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool load( const std::string& file_name )
{
std::ifstream stream;
@ -105,11 +96,11 @@ class elfio
return false;
}
return load(stream);
return load( stream );
}
//------------------------------------------------------------------------------
bool load( std::istream &stream )
//------------------------------------------------------------------------------
bool load( std::istream& stream )
{
clean();
@ -119,15 +110,13 @@ class elfio
// Is it ELF file?
if ( stream.gcount() != sizeof( e_ident ) ||
e_ident[EI_MAG0] != ELFMAG0 ||
e_ident[EI_MAG1] != ELFMAG1 ||
e_ident[EI_MAG2] != ELFMAG2 ||
e_ident[EI_MAG3] != ELFMAG3 ) {
e_ident[EI_MAG0] != ELFMAG0 || e_ident[EI_MAG1] != ELFMAG1 ||
e_ident[EI_MAG2] != ELFMAG2 || e_ident[EI_MAG3] != ELFMAG3 ) {
return false;
}
if ( ( e_ident[EI_CLASS] != ELFCLASS64 ) &&
( e_ident[EI_CLASS] != ELFCLASS32 )) {
( e_ident[EI_CLASS] != ELFCLASS32 ) ) {
return false;
}
@ -145,7 +134,7 @@ class elfio
return is_still_good;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool save( const std::string& file_name )
{
std::ofstream stream;
@ -154,13 +143,13 @@ class elfio
return false;
}
return save(stream);
return save( stream );
}
//------------------------------------------------------------------------------
bool save( std::ostream &stream )
//------------------------------------------------------------------------------
bool save( std::ostream& stream )
{
if ( !stream || !header) {
if ( !stream || !header ) {
return false;
}
@ -170,13 +159,15 @@ class elfio
// The position of the section table is variable and needs to be fixed
// before saving.
header->set_segments_num( segments.size() );
header->set_segments_offset( segments.size() ? header->get_header_size() : 0 );
header->set_segments_offset( segments.size() ? header->get_header_size()
: 0 );
header->set_sections_num( sections.size() );
header->set_sections_offset( 0 );
// Layout the first section right after the segment table
current_file_pos = header->get_header_size() +
header->get_segment_entry_size() * (Elf_Xword)header->get_segments_num();
header->get_segment_entry_size() *
(Elf_Xword)header->get_segments_num();
calc_segment_alignment();
@ -191,7 +182,7 @@ class elfio
return is_still_good;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// ELF header access functions
ELFIO_HEADER_ACCESS_GET( unsigned char, class );
ELFIO_HEADER_ACCESS_GET( unsigned char, elf_version );
@ -211,16 +202,13 @@ class elfio
ELFIO_HEADER_ACCESS_GET_SET( Elf64_Off, segments_offset );
ELFIO_HEADER_ACCESS_GET_SET( Elf_Half, section_name_str_index );
//------------------------------------------------------------------------------
const endianess_convertor& get_convertor() const
{
return convertor;
}
//------------------------------------------------------------------------------
const endianess_convertor& get_convertor() const { return convertor; }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Elf_Xword get_default_entry_size( Elf_Word section_type ) const
{
switch( section_type ) {
switch ( section_type ) {
case SHT_RELA:
if ( header->get_class() == ELFCLASS64 ) {
return sizeof( Elf64_Rela );
@ -254,35 +242,38 @@ class elfio
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
bool is_offset_in_section( Elf64_Off offset, const section* sec ) const {
return offset >= sec->get_offset() && offset < sec->get_offset()+sec->get_size();
bool is_offset_in_section( Elf64_Off offset, const section* sec ) const
{
return ( offset >= sec->get_offset() ) &&
( offset < ( sec->get_offset() + sec->get_size() ) );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
public:
//! returns an empty string if no problems are detected,
//! or a string containing an error message if problems are found
std::string validate() const {
std::string validate() const
{
// check for overlapping sections in the file
for ( int i = 0; i < sections.size(); ++i) {
for ( int j = i+1; j < sections.size(); ++j ) {
for ( int i = 0; i < sections.size(); ++i ) {
for ( int j = i + 1; j < sections.size(); ++j ) {
const section* a = sections[i];
const section* b = sections[j];
if ( !(a->get_type() & SHT_NOBITS)
&& !(b->get_type() & SHT_NOBITS)
&& (a->get_size() > 0)
&& (b->get_size() > 0)
&& (a->get_offset() > 0)
&& (b->get_offset() > 0)) {
if ( is_offset_in_section( a->get_offset(), b )
|| is_offset_in_section( a->get_offset()+a->get_size()-1, b )
|| is_offset_in_section( b->get_offset(), a )
|| is_offset_in_section( b->get_offset()+b->get_size()-1, a )) {
return "Sections " + a->get_name() + " and " + b->get_name() + " overlap in file";
if ( !( a->get_type() & SHT_NOBITS ) &&
!( b->get_type() & SHT_NOBITS ) && ( a->get_size() > 0 ) &&
( b->get_size() > 0 ) && ( a->get_offset() > 0 ) &&
( b->get_offset() > 0 ) ) {
if ( is_offset_in_section( a->get_offset(), b ) ||
is_offset_in_section(
a->get_offset() + a->get_size() - 1, b ) ||
is_offset_in_section( b->get_offset(), a ) ||
is_offset_in_section(
b->get_offset() + b->get_size() - 1, a ) ) {
return "Sections " + a->get_name() + " and " +
b->get_name() + " overlap in file";
}
}
}
@ -293,9 +284,9 @@ class elfio
return "";
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void clean()
{
delete header;
@ -314,18 +305,19 @@ class elfio
segments_.clear();
}
//------------------------------------------------------------------------------
elf_header* create_header( unsigned char file_class, unsigned char encoding )
//------------------------------------------------------------------------------
elf_header* create_header( unsigned char file_class,
unsigned char encoding )
{
elf_header* new_header = 0;
if ( file_class == ELFCLASS64 ) {
new_header = new elf_header_impl< Elf64_Ehdr >( &convertor,
encoding );
new_header =
new elf_header_impl<Elf64_Ehdr>( &convertor, encoding );
}
else if ( file_class == ELFCLASS32 ) {
new_header = new elf_header_impl< Elf32_Ehdr >( &convertor,
encoding );
new_header =
new elf_header_impl<Elf32_Ehdr>( &convertor, encoding );
}
else {
return 0;
@ -334,7 +326,7 @@ class elfio
return new_header;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
section* create_section()
{
section* new_section;
@ -356,8 +348,7 @@ class elfio
return new_section;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
segment* create_segment()
{
segment* new_segment;
@ -379,7 +370,7 @@ class elfio
return new_segment;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void create_mandatory_sections()
{
// Create null section without calling to 'add_section' as no string
@ -395,7 +386,7 @@ class elfio
shstrtab->set_addr_align( 1 );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Elf_Half load_sections( std::istream& stream )
{
Elf_Half entry_size = header->get_section_entry_size();
@ -404,7 +395,8 @@ class elfio
for ( Elf_Half i = 0; i < num; ++i ) {
section* sec = create_section();
sec->load( stream, (std::streamoff)offset + (std::streampos)i * entry_size );
sec->load( stream, (std::streamoff)offset +
(std::streampos)i * entry_size );
sec->set_index( i );
// To mark that the section is not permitted to reassign address
// during layout calculation
@ -427,19 +419,24 @@ class elfio
return num;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//! Checks whether the addresses of the section entirely fall within the given segment.
//! It doesn't matter if the addresses are memory addresses, or file offsets,
//! they just need to be in the same address space
bool is_sect_in_seg ( Elf64_Off sect_begin, Elf_Xword sect_size, Elf64_Off seg_begin, Elf64_Off seg_end ) {
return seg_begin <= sect_begin
&& sect_begin + sect_size <= seg_end
&& sect_begin < seg_end; // this is important criteria when sect_size == 0
bool is_sect_in_seg( Elf64_Off sect_begin,
Elf_Xword sect_size,
Elf64_Off seg_begin,
Elf64_Off seg_end )
{
return ( seg_begin <= sect_begin ) &&
( sect_begin + sect_size <= seg_end ) &&
( sect_begin <
seg_end ); // this is important criteria when sect_size == 0
// Example: seg_begin=10, seg_end=12 (-> covering the bytes 10 and 11)
// sect_begin=12, sect_size=0 -> shall return false!
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool load_segments( std::istream& stream )
{
Elf_Half entry_size = header->get_segment_entry_size();
@ -460,7 +457,8 @@ class elfio
return false;
}
seg->load( stream, (std::streamoff)offset + (std::streampos)i * entry_size );
seg->load( stream, (std::streamoff)offset +
(std::streampos)i * entry_size );
seg->set_index( i );
// Add sections to the segments (similar to readelfs algorithm)
@ -468,14 +466,17 @@ class elfio
Elf64_Off segEndOffset = segBaseOffset + seg->get_file_size();
Elf64_Off segVBaseAddr = seg->get_virtual_address();
Elf64_Off segVEndAddr = segVBaseAddr + seg->get_memory_size();
for( Elf_Half j = 0; j < sections.size(); ++j ) {
for ( Elf_Half j = 0; j < sections.size(); ++j ) {
const section* psec = sections[j];
// SHF_ALLOC sections are matched based on the virtual address
// otherwise the file offset is matched
if( psec->get_flags() & SHF_ALLOC
? is_sect_in_seg( psec->get_address(), psec->get_size(), segVBaseAddr, segVEndAddr )
: is_sect_in_seg( psec->get_offset(), psec->get_size(), segBaseOffset, segEndOffset )) {
if ( ( psec->get_flags() & SHF_ALLOC )
? is_sect_in_seg( psec->get_address(),
psec->get_size(), segVBaseAddr,
segVEndAddr )
: is_sect_in_seg( psec->get_offset(), psec->get_size(),
segBaseOffset, segEndOffset ) ) {
// Alignment of segment shall not be updated, to preserve original value
// It will be re-calculated on saving.
seg->add_section_index( psec->get_index(), 0 );
@ -489,50 +490,49 @@ class elfio
return true;
}
//------------------------------------------------------------------------------
bool save_header( std::ostream& stream )
{
return header->save( stream );
}
//------------------------------------------------------------------------------
bool save_header( std::ostream& stream ) { return header->save( stream ); }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool save_sections( std::ostream& stream )
{
for ( unsigned int i = 0; i < sections_.size(); ++i ) {
section *sec = sections_.at(i);
section* sec = sections_.at( i );
std::streampos headerPosition =
(std::streamoff)header->get_sections_offset() +
(std::streampos)header->get_section_entry_size() * sec->get_index();
(std::streampos)header->get_section_entry_size() *
sec->get_index();
sec->save(stream,headerPosition,sec->get_offset());
sec->save( stream, headerPosition, sec->get_offset() );
}
return true;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool save_segments( std::ostream& stream )
{
for ( unsigned int i = 0; i < segments_.size(); ++i ) {
segment *seg = segments_.at(i);
segment* seg = segments_.at( i );
std::streampos headerPosition = header->get_segments_offset() +
(std::streampos)header->get_segment_entry_size()*seg->get_index();
std::streampos headerPosition =
header->get_segments_offset() +
(std::streampos)header->get_segment_entry_size() *
seg->get_index();
seg->save( stream, headerPosition, seg->get_offset() );
}
return true;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool is_section_without_segment( unsigned int section_index )
{
bool found = false;
for ( unsigned int j = 0; !found && ( j < segments.size() ); ++j ) {
for ( unsigned int k = 0;
!found && ( k < segments[j]->get_sections_num() );
++k ) {
!found && ( k < segments[j]->get_sections_num() ); ++k ) {
found = segments[j]->get_section_index_at( k ) == section_index;
}
}
@ -540,7 +540,7 @@ class elfio
return !found;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool is_subsequence_of( segment* seg1, segment* seg2 )
{
// Return 'true' if sections of seg1 are a subset of sections in seg2
@ -556,31 +556,31 @@ class elfio
return found;
}
//------------------------------------------------------------------------------
std::vector<segment*> get_ordered_segments( )
//------------------------------------------------------------------------------
std::vector<segment*> get_ordered_segments()
{
std::vector<segment*> res;
std::deque<segment*> worklist;
res.reserve(segments.size());
res.reserve( segments.size() );
std::copy( segments_.begin(), segments_.end(),
std::back_inserter( worklist )) ;
std::back_inserter( worklist ) );
// Bring the segments which start at address 0 to the front
size_t nextSlot = 0;
for( size_t i = 0; i < worklist.size(); ++i ) {
if( i != nextSlot && worklist[i]->is_offset_initialized()
&& worklist[i]->get_offset() == 0 ) {
if (worklist[nextSlot]->get_offset() == 0) {
for ( size_t i = 0; i < worklist.size(); ++i ) {
if ( i != nextSlot && worklist[i]->is_offset_initialized() &&
worklist[i]->get_offset() == 0 ) {
if ( worklist[nextSlot]->get_offset() == 0 ) {
++nextSlot;
}
std::swap(worklist[i],worklist[nextSlot]);
std::swap( worklist[i], worklist[nextSlot] );
++nextSlot;
}
}
while ( !worklist.empty() ) {
segment *seg = worklist.front();
segment* seg = worklist.front();
worklist.pop_front();
size_t i = 0;
@ -591,30 +591,30 @@ class elfio
}
if ( i < worklist.size() )
worklist.push_back(seg);
worklist.push_back( seg );
else
res.push_back(seg);
res.push_back( seg );
}
return res;
}
//------------------------------------------------------------------------------
bool layout_sections_without_segments( )
//------------------------------------------------------------------------------
bool layout_sections_without_segments()
{
for ( unsigned int i = 0; i < sections_.size(); ++i ) {
if ( is_section_without_segment( i ) ) {
section *sec = sections_[i];
section* sec = sections_[i];
Elf_Xword section_align = sec->get_addr_align();
if ( section_align > 1 && current_file_pos % section_align != 0 ) {
current_file_pos += section_align -
current_file_pos % section_align;
if ( section_align > 1 &&
current_file_pos % section_align != 0 ) {
current_file_pos +=
section_align - current_file_pos % section_align;
}
if ( 0 != sec->get_index() )
sec->set_offset(current_file_pos);
sec->set_offset( current_file_pos );
if ( SHT_NOBITS != sec->get_type() &&
SHT_NULL != sec->get_type() ) {
@ -626,14 +626,14 @@ class elfio
return true;
}
//------------------------------------------------------------------------------
void calc_segment_alignment( )
//------------------------------------------------------------------------------
void calc_segment_alignment()
{
for( std::vector<segment*>::iterator s = segments_.begin(); s != segments_.end(); ++s ) {
for ( std::vector<segment*>::iterator s = segments_.begin();
s != segments_.end(); ++s ) {
segment* seg = *s;
for ( int i = 0; i < seg->get_sections_num(); ++i ) {
section* sect = sections_[ seg->get_section_index_at(i) ];
section* sect = sections_[seg->get_section_index_at( i )];
if ( sect->get_addr_align() > seg->get_align() ) {
seg->set_align( sect->get_addr_align() );
}
@ -641,11 +641,11 @@ class elfio
}
}
//------------------------------------------------------------------------------
bool layout_segments_and_their_sections( )
//------------------------------------------------------------------------------
bool layout_segments_and_their_sections()
{
std::vector<segment*> worklist;
std::vector<bool> section_generated(sections.size(),false);
std::vector<bool> section_generated( sections.size(), false );
// Get segments in a order in where segments which contain a
// sub sequence of other segments are located at the end
@ -662,7 +662,8 @@ class elfio
if ( seg->get_type() == PT_PHDR && seg->get_sections_num() == 0 ) {
seg_start_pos = header->get_segments_offset();
segment_memory = segment_filesize =
header->get_segment_entry_size() * (Elf_Xword)header->get_segments_num();
header->get_segment_entry_size() *
(Elf_Xword)header->get_segments_num();
}
// Special case:
else if ( seg->is_offset_initialized() && seg->get_offset() == 0 ) {
@ -673,76 +674,82 @@ class elfio
}
// New segments with not generated sections
// have to be aligned
else if ( seg->get_sections_num()
&& !section_generated[seg->get_section_index_at( 0 )] ) {
else if ( seg->get_sections_num() &&
!section_generated[seg->get_section_index_at( 0 )] ) {
Elf_Xword align = seg->get_align() > 0 ? seg->get_align() : 1;
Elf64_Off cur_page_alignment = current_file_pos % align;
Elf64_Off req_page_alignment = seg->get_virtual_address() % align;
Elf64_Off req_page_alignment =
seg->get_virtual_address() % align;
Elf64_Off error = req_page_alignment - cur_page_alignment;
current_file_pos += ( seg->get_align() + error ) % align;
seg_start_pos = current_file_pos;
}
else if ( seg->get_sections_num() ) {
seg_start_pos = sections[seg->get_section_index_at( 0 )]->get_offset();
seg_start_pos =
sections[seg->get_section_index_at( 0 )]->get_offset();
}
// Write segment's data
for ( unsigned int j = 0; j < seg->get_sections_num(); ++j ) {
Elf_Half index = seg->get_section_index_at( j );
section* sec = sections[ index ];
section* sec = sections[index];
// The NULL section is always generated
if ( SHT_NULL == sec->get_type()) {
if ( SHT_NULL == sec->get_type() ) {
section_generated[index] = true;
continue;
}
Elf_Xword secAlign = 0;
// Fix up the alignment
if ( !section_generated[index] && sec->is_address_initialized()
&& SHT_NOBITS != sec->get_type()
&& SHT_NULL != sec->get_type()
&& 0 != sec->get_size() ) {
if ( !section_generated[index] &&
sec->is_address_initialized() &&
SHT_NOBITS != sec->get_type() &&
SHT_NULL != sec->get_type() && 0 != sec->get_size() ) {
// Align the sections based on the virtual addresses
// when possible (this is what matters for execution)
Elf64_Off req_offset = sec->get_address() - seg->get_virtual_address();
Elf64_Off req_offset =
sec->get_address() - seg->get_virtual_address();
Elf64_Off cur_offset = current_file_pos - seg_start_pos;
if ( req_offset < cur_offset) {
if ( req_offset < cur_offset ) {
// something has gone awfully wrong, abort!
// secAlign would turn out negative, seeking backwards and overwriting previous data
return false;
}
secAlign = req_offset - cur_offset;
}
else if (!section_generated[index] && !sec->is_address_initialized() ) {
else if ( !section_generated[index] &&
!sec->is_address_initialized() ) {
// If no address has been specified then only the section
// alignment constraint has to be matched
Elf_Xword align = sec->get_addr_align();
if (align == 0) {
if ( align == 0 ) {
align = 1;
}
Elf64_Off error = current_file_pos % align;
secAlign = ( align - error ) % align;
}
else if (section_generated[index] ) {
else if ( section_generated[index] ) {
// Alignment for already generated sections
secAlign = sec->get_offset() - seg_start_pos - segment_filesize;
secAlign =
sec->get_offset() - seg_start_pos - segment_filesize;
}
// Determine the segment file and memory sizes
// Special case .tbss section (NOBITS) in non TLS segment
if ( (sec->get_flags() & SHF_ALLOC)
&& !( (sec->get_flags() & SHF_TLS) && (seg->get_type() != PT_TLS)
&& ( SHT_NOBITS == sec->get_type())) )
if ( ( sec->get_flags() & SHF_ALLOC ) &&
!( ( sec->get_flags() & SHF_TLS ) &&
( seg->get_type() != PT_TLS ) &&
( SHT_NOBITS == sec->get_type() ) ) )
segment_memory += sec->get_size() + secAlign;
if ( SHT_NOBITS != sec->get_type() )
segment_filesize += sec->get_size() + secAlign;
// Nothing to be done when generating nested segments
if(section_generated[index]) {
if ( section_generated[index] ) {
continue;
}
@ -750,11 +757,11 @@ class elfio
// Set the section addresses when missing
if ( !sec->is_address_initialized() )
sec->set_address( seg->get_virtual_address()
+ current_file_pos - seg_start_pos);
sec->set_address( seg->get_virtual_address() +
current_file_pos - seg_start_pos );
if ( 0 != sec->get_index() )
sec->set_offset(current_file_pos);
sec->set_offset( current_file_pos );
if ( SHT_NOBITS != sec->get_type() )
current_file_pos += sec->get_size();
@ -772,41 +779,35 @@ class elfio
seg->set_memory_size( segment_memory );
}
seg->set_offset(seg_start_pos);
seg->set_offset( seg_start_pos );
}
return true;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool layout_section_table()
{
// Simply place the section table at the end for now
Elf64_Off alignmentError = current_file_pos % 4;
current_file_pos += ( 4 - alignmentError ) % 4;
header->set_sections_offset(current_file_pos);
header->set_sections_offset( current_file_pos );
return true;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
public:
friend class Sections;
class Sections {
class Sections
{
public:
//------------------------------------------------------------------------------
Sections( elfio* parent_ ) :
parent( parent_ )
{
}
//------------------------------------------------------------------------------
Sections( elfio* parent_ ) : parent( parent_ ) {}
//------------------------------------------------------------------------------
Elf_Half size() const
{
return (Elf_Half)parent->sections_.size();
}
//------------------------------------------------------------------------------
Elf_Half size() const { return (Elf_Half)parent->sections_.size(); }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
section* operator[]( unsigned int index ) const
{
section* sec = 0;
@ -818,16 +819,15 @@ class elfio
return sec;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
section* operator[]( const std::string& name ) const
{
section* sec = 0;
std::vector<section*>::const_iterator it;
for ( it = parent->sections_.begin();
it != parent->sections_.end();
for ( it = parent->sections_.begin(); it != parent->sections_.end();
++it ) {
if ( (*it)->get_name() == name ) {
if ( ( *it )->get_name() == name ) {
sec = *it;
break;
}
@ -836,7 +836,7 @@ class elfio
return sec;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
section* add( const std::string& name )
{
section* new_section = parent->create_section();
@ -851,87 +851,86 @@ class elfio
return new_section;
}
//------------------------------------------------------------------------------
std::vector<section*>::iterator begin() {
//------------------------------------------------------------------------------
std::vector<section*>::iterator begin()
{
return parent->sections_.begin();
}
//------------------------------------------------------------------------------
std::vector<section*>::iterator end() {
//------------------------------------------------------------------------------
std::vector<section*>::iterator end()
{
return parent->sections_.end();
}
//------------------------------------------------------------------------------
std::vector<section*>::const_iterator begin() const {
//------------------------------------------------------------------------------
std::vector<section*>::const_iterator begin() const
{
return parent->sections_.cbegin();
}
//------------------------------------------------------------------------------
std::vector<section*>::const_iterator end() const {
//------------------------------------------------------------------------------
std::vector<section*>::const_iterator end() const
{
return parent->sections_.cend();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
elfio* parent;
} sections;
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
public:
friend class Segments;
class Segments {
class Segments
{
public:
//------------------------------------------------------------------------------
Segments( elfio* parent_ ) :
parent( parent_ )
{
}
//------------------------------------------------------------------------------
Segments( elfio* parent_ ) : parent( parent_ ) {}
//------------------------------------------------------------------------------
Elf_Half size() const
{
return (Elf_Half)parent->segments_.size();
}
//------------------------------------------------------------------------------
Elf_Half size() const { return (Elf_Half)parent->segments_.size(); }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
segment* operator[]( unsigned int index ) const
{
return parent->segments_[index];
}
//------------------------------------------------------------------------------
segment* add() { return parent->create_segment(); }
//------------------------------------------------------------------------------
segment* add()
//------------------------------------------------------------------------------
std::vector<segment*>::iterator begin()
{
return parent->create_segment();
}
//------------------------------------------------------------------------------
std::vector<segment*>::iterator begin() {
return parent->segments_.begin();
}
//------------------------------------------------------------------------------
std::vector<segment*>::iterator end() {
//------------------------------------------------------------------------------
std::vector<segment*>::iterator end()
{
return parent->segments_.end();
}
//------------------------------------------------------------------------------
std::vector<segment*>::const_iterator begin() const {
//------------------------------------------------------------------------------
std::vector<segment*>::const_iterator begin() const
{
return parent->segments_.cbegin();
}
//------------------------------------------------------------------------------
std::vector<segment*>::const_iterator end() const {
//------------------------------------------------------------------------------
std::vector<segment*>::const_iterator end() const
{
return parent->segments_.cend();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
elfio* parent;
} segments;
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
elf_header* header;
std::vector<section*> sections_;
@ -949,7 +948,7 @@ class elfio
#include <elfio/elfio_dynamic.hpp>
#ifdef _MSC_VER
#pragma warning ( pop )
#pragma warning( pop )
#endif
#endif // ELFIO_HPP

970
elfio/elfio_dump.hpp
View File

File diff suppressed because it is too large Load Diff

84
elfio/elfio_dynamic.hpp
View File

@ -26,33 +26,30 @@ THE SOFTWARE.
namespace ELFIO {
//------------------------------------------------------------------------------
template< class S >
class dynamic_section_accessor_template
template <class S> class dynamic_section_accessor_template
{
public:
//------------------------------------------------------------------------------
dynamic_section_accessor_template( const elfio& elf_file_, S* section_ ) :
elf_file( elf_file_ ),
dynamic_section( section_ )
//------------------------------------------------------------------------------
dynamic_section_accessor_template( const elfio& elf_file_, S* section_ )
: elf_file( elf_file_ ), dynamic_section( section_ )
{
}
//------------------------------------------------------------------------------
Elf_Xword
get_entries_num() const
//------------------------------------------------------------------------------
Elf_Xword get_entries_num() const
{
Elf_Xword nRet = 0;
if ( 0 != dynamic_section->get_entry_size() ) {
nRet = dynamic_section->get_size() / dynamic_section->get_entry_size();
nRet =
dynamic_section->get_size() / dynamic_section->get_entry_size();
}
return nRet;
}
//------------------------------------------------------------------------------
bool
get_entry( Elf_Xword index,
//------------------------------------------------------------------------------
bool get_entry( Elf_Xword index,
Elf_Xword& tag,
Elf_Xword& value,
std::string& str ) const
@ -62,19 +59,17 @@ class dynamic_section_accessor_template
}
if ( elf_file.get_class() == ELFCLASS32 ) {
generic_get_entry_dyn< Elf32_Dyn >( index, tag, value );
generic_get_entry_dyn<Elf32_Dyn>( index, tag, value );
}
else {
generic_get_entry_dyn< Elf64_Dyn >( index, tag, value );
generic_get_entry_dyn<Elf64_Dyn>( index, tag, value );
}
// If the tag may have a string table reference, prepare the string
if ( tag == DT_NEEDED ||
tag == DT_SONAME ||
tag == DT_RPATH ||
if ( tag == DT_NEEDED || tag == DT_SONAME || tag == DT_RPATH ||
tag == DT_RUNPATH ) {
string_section_accessor strsec =
elf_file.sections[ get_string_table_index() ];
elf_file.sections[get_string_table_index()];
const char* result = strsec.get_string( value );
if ( 0 == result ) {
str.clear();
@ -89,51 +84,46 @@ class dynamic_section_accessor_template
return true;
}
//------------------------------------------------------------------------------
void
add_entry( Elf_Xword tag,
Elf_Xword value )
//------------------------------------------------------------------------------
void add_entry( Elf_Xword tag, Elf_Xword value )
{
if ( elf_file.get_class() == ELFCLASS32 ) {
generic_add_entry< Elf32_Dyn >( tag, value );
generic_add_entry<Elf32_Dyn>( tag, value );
}
else {
generic_add_entry< Elf64_Dyn >( tag, value );
generic_add_entry<Elf64_Dyn>( tag, value );
}
}
//------------------------------------------------------------------------------
void
add_entry( Elf_Xword tag,
const std::string& str )
//------------------------------------------------------------------------------
void add_entry( Elf_Xword tag, const std::string& str )
{
string_section_accessor strsec =
elf_file.sections[ get_string_table_index() ];
elf_file.sections[get_string_table_index()];
Elf_Xword value = strsec.add_string( str );
add_entry( tag, value );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
//------------------------------------------------------------------------------
Elf_Half
get_string_table_index() const
//------------------------------------------------------------------------------
Elf_Half get_string_table_index() const
{
return (Elf_Half)dynamic_section->get_link();
}
//------------------------------------------------------------------------------
template< class T >
void
generic_get_entry_dyn( Elf_Xword index,
//------------------------------------------------------------------------------
template <class T>
void generic_get_entry_dyn( Elf_Xword index,
Elf_Xword& tag,
Elf_Xword& value ) const
{
const endianess_convertor& convertor = elf_file.get_convertor();
// Check unusual case when dynamic section has no data
if( dynamic_section->get_data() == 0 ||
( index + 1 ) * dynamic_section->get_entry_size() > dynamic_section->get_size() ) {
if ( dynamic_section->get_data() == 0 ||
( index + 1 ) * dynamic_section->get_entry_size() >
dynamic_section->get_size() ) {
tag = DT_NULL;
value = 0;
return;
@ -187,10 +177,8 @@ class dynamic_section_accessor_template
}
}
//------------------------------------------------------------------------------
template< class T >
void
generic_add_entry( Elf_Xword tag, Elf_Xword value )
//------------------------------------------------------------------------------
template <class T> void generic_add_entry( Elf_Xword tag, Elf_Xword value )
{
const endianess_convertor& convertor = elf_file.get_convertor();
@ -240,17 +228,19 @@ class dynamic_section_accessor_template
entry.d_tag = convertor( tag );
dynamic_section->append_data( reinterpret_cast<char*>( &entry ), sizeof( entry ) );
dynamic_section->append_data( reinterpret_cast<char*>( &entry ),
sizeof( entry ) );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
const elfio& elf_file;
S* dynamic_section;
};
using dynamic_section_accessor = dynamic_section_accessor_template<section>;
using const_dynamic_section_accessor = dynamic_section_accessor_template<const section>;
using const_dynamic_section_accessor =
dynamic_section_accessor_template<const section>;
} // namespace ELFIO

52
elfio/elfio_header.hpp
View File

@ -30,7 +30,7 @@ namespace ELFIO {
class elf_header
{
public:
virtual ~elf_header() {};
virtual ~elf_header(){};
virtual bool load( std::istream& stream ) = 0;
virtual bool save( std::ostream& stream ) const = 0;
@ -56,29 +56,30 @@ class elf_header
ELFIO_GET_SET_ACCESS_DECL( Elf_Half, section_name_str_index );
};
template< class T > struct elf_header_impl_types;
template<> struct elf_header_impl_types<Elf32_Ehdr> {
template <class T> struct elf_header_impl_types;
template <> struct elf_header_impl_types<Elf32_Ehdr>
{
typedef Elf32_Phdr Phdr_type;
typedef Elf32_Shdr Shdr_type;
static const unsigned char file_class = ELFCLASS32;
};
template<> struct elf_header_impl_types<Elf64_Ehdr> {
template <> struct elf_header_impl_types<Elf64_Ehdr>
{
typedef Elf64_Phdr Phdr_type;
typedef Elf64_Shdr Shdr_type;
static const unsigned char file_class = ELFCLASS64;
};
template< class T > class elf_header_impl : public elf_header
template <class T> class elf_header_impl : public elf_header
{
public:
//------------------------------------------------------------------------------
elf_header_impl( endianess_convertor* convertor_,
unsigned char encoding )
elf_header_impl( endianess_convertor* convertor_, unsigned char encoding )
{
convertor = convertor_;
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ), '\0' );
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ),
'\0' );
header.e_ident[EI_MAG0] = ELFMAG0;
header.e_ident[EI_MAG1] = ELFMAG1;
@ -87,32 +88,33 @@ template< class T > class elf_header_impl : public elf_header
header.e_ident[EI_CLASS] = elf_header_impl_types<T>::file_class;
header.e_ident[EI_DATA] = encoding;
header.e_ident[EI_VERSION] = EV_CURRENT;
header.e_version = (*convertor)( (Elf_Word)EV_CURRENT );
header.e_version = ( *convertor )( (Elf_Word)EV_CURRENT );
header.e_ehsize = ( sizeof( header ) );
header.e_ehsize = (*convertor)( header.e_ehsize );
header.e_shstrndx = (*convertor)( (Elf_Half)1 );
header.e_phentsize = sizeof( typename elf_header_impl_types<T>::Phdr_type );
header.e_shentsize = sizeof( typename elf_header_impl_types<T>::Shdr_type );
header.e_phentsize = (*convertor)( header.e_phentsize );
header.e_shentsize = (*convertor)( header.e_shentsize );
header.e_ehsize = ( *convertor )( header.e_ehsize );
header.e_shstrndx = ( *convertor )( (Elf_Half)1 );
header.e_phentsize =
sizeof( typename elf_header_impl_types<T>::Phdr_type );
header.e_shentsize =
sizeof( typename elf_header_impl_types<T>::Shdr_type );
header.e_phentsize = ( *convertor )( header.e_phentsize );
header.e_shentsize = ( *convertor )( header.e_shentsize );
}
//------------------------------------------------------------------------------
bool
load( std::istream& stream )
bool load( std::istream& stream )
{
stream.seekg( 0 );
stream.read( reinterpret_cast<char*>( &header ), sizeof( header ) );
return (stream.gcount() == sizeof( header ) );
return ( stream.gcount() == sizeof( header ) );
}
//------------------------------------------------------------------------------
bool
save( std::ostream& stream ) const
bool save( std::ostream& stream ) const
{
stream.seekp( 0 );
stream.write( reinterpret_cast<const char*>( &header ), sizeof( header ) );
stream.write( reinterpret_cast<const char*>( &header ),
sizeof( header ) );
return stream.good();
}
@ -126,9 +128,11 @@ template< class T > class elf_header_impl : public elf_header
ELFIO_GET_ACCESS( Elf_Half, section_entry_size, header.e_shentsize );
ELFIO_GET_ACCESS( Elf_Half, segment_entry_size, header.e_phentsize );
ELFIO_GET_SET_ACCESS( Elf_Word, version, header.e_version);
ELFIO_GET_SET_ACCESS( Elf_Word, version, header.e_version );
ELFIO_GET_SET_ACCESS( unsigned char, os_abi, header.e_ident[EI_OSABI] );
ELFIO_GET_SET_ACCESS( unsigned char, abi_version, header.e_ident[EI_ABIVERSION] );
ELFIO_GET_SET_ACCESS( unsigned char,
abi_version,
header.e_ident[EI_ABIVERSION] );
ELFIO_GET_SET_ACCESS( Elf_Half, type, header.e_type );
ELFIO_GET_SET_ACCESS( Elf_Half, machine, header.e_machine );
ELFIO_GET_SET_ACCESS( Elf_Word, flags, header.e_flags );

54
elfio/elfio_note.hpp
View File

@ -38,27 +38,24 @@ namespace ELFIO {
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template< class S >
class note_section_accessor_template
template <class S> class note_section_accessor_template
{
public:
//------------------------------------------------------------------------------
note_section_accessor_template( const elfio& elf_file_, S* section_ ) :
elf_file( elf_file_ ), note_section( section_ )
//------------------------------------------------------------------------------
note_section_accessor_template( const elfio& elf_file_, S* section_ )
: elf_file( elf_file_ ), note_section( section_ )
{
process_section();
}
//------------------------------------------------------------------------------
Elf_Word
get_notes_num() const
//------------------------------------------------------------------------------
Elf_Word get_notes_num() const
{
return (Elf_Word)note_start_positions.size();
}
//------------------------------------------------------------------------------
bool
get_note( Elf_Word index,
//------------------------------------------------------------------------------
bool get_note( Elf_Word index,
Elf_Word& type,
std::string& name,
void*& desc,
@ -68,33 +65,35 @@ class note_section_accessor_template
return false;
}
const char* pData = note_section->get_data() + note_start_positions[index];
const char* pData =
note_section->get_data() + note_start_positions[index];
int align = sizeof( Elf_Word );
const endianess_convertor& convertor = elf_file.get_convertor();
type = convertor( *(const Elf_Word*)( pData + 2*align ) );
type = convertor( *(const Elf_Word*)( pData + 2 * align ) );
Elf_Word namesz = convertor( *(const Elf_Word*)( pData ) );
descSize = convertor( *(const Elf_Word*)( pData + sizeof( namesz ) ) );
Elf_Xword max_name_size = note_section->get_size() - note_start_positions[index];
if ( namesz < 1 ||
namesz > max_name_size ||
Elf_Xword max_name_size =
note_section->get_size() - note_start_positions[index];
if ( namesz < 1 || namesz > max_name_size ||
(Elf_Xword)namesz + descSize > max_name_size ) {
return false;
}
name.assign( pData + 3*align, namesz - 1);
name.assign( pData + 3 * align, namesz - 1 );
if ( 0 == descSize ) {
desc = 0;
}
else {
desc = const_cast<char*> ( pData + 3*align +
( ( namesz + align - 1 )/align )*align );
desc =
const_cast<char*>( pData + 3 * align +
( ( namesz + align - 1 ) / align ) * align );
}
return true;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void add_note( Elf_Word type,
const std::string& name,
const void* desc,
@ -107,6 +106,7 @@ class note_section_accessor_template
Elf_Word nameLenConv = convertor( nameLen );
std::string buffer( reinterpret_cast<char*>( &nameLenConv ), align );
Elf_Word descSizeConv = convertor( descSize );
buffer.append( reinterpret_cast<char*>( &descSizeConv ), align );
type = convertor( type );
buffer.append( reinterpret_cast<char*>( &type ), align );
@ -128,7 +128,7 @@ class note_section_accessor_template
}
private:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void process_section()
{
const endianess_convertor& convertor = elf_file.get_convertor();
@ -144,20 +144,19 @@ class note_section_accessor_template
}
Elf_Word align = sizeof( Elf_Word );
while ( current + (Elf_Xword)3*align <= size ) {
while ( current + (Elf_Xword)3 * align <= size ) {
note_start_positions.push_back( current );
Elf_Word namesz = convertor(
*(const Elf_Word*)( data + current ) );
Elf_Word namesz = convertor( *(const Elf_Word*)( data + current ) );
Elf_Word descsz = convertor(
*(const Elf_Word*)( data + current + sizeof( namesz ) ) );
current += (Elf_Xword)3*sizeof( Elf_Word ) +
current += (Elf_Xword)3 * sizeof( Elf_Word ) +
( ( namesz + align - 1 ) / align ) * (Elf_Xword)align +
( ( descsz + align - 1 ) / align ) * (Elf_Xword)align;
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
const elfio& elf_file;
S* note_section;
@ -165,7 +164,8 @@ class note_section_accessor_template
};
using note_section_accessor = note_section_accessor_template<section>;
using const_note_section_accessor = note_section_accessor_template<const section>;
using const_note_section_accessor =
note_section_accessor_template<const section>;
} // namespace ELFIO

258
elfio/elfio_relocation.hpp
View File

@ -25,8 +25,8 @@ THE SOFTWARE.
namespace ELFIO {
template<typename T> struct get_sym_and_type;
template<> struct get_sym_and_type< Elf32_Rel >
template <typename T> struct get_sym_and_type;
template <> struct get_sym_and_type<Elf32_Rel>
{
static int get_r_sym( Elf_Xword info )
{
@ -37,7 +37,7 @@ template<> struct get_sym_and_type< Elf32_Rel >
return ELF32_R_TYPE( (Elf_Word)info );
}
};
template<> struct get_sym_and_type< Elf32_Rela >
template <> struct get_sym_and_type<Elf32_Rela>
{
static int get_r_sym( Elf_Xword info )
{
@ -48,58 +48,42 @@ template<> struct get_sym_and_type< Elf32_Rela >
return ELF32_R_TYPE( (Elf_Word)info );
}
};
template<> struct get_sym_and_type< Elf64_Rel >
template <> struct get_sym_and_type<Elf64_Rel>
{
static int get_r_sym( Elf_Xword info )
{
return ELF64_R_SYM( info );
}
static int get_r_type( Elf_Xword info )
{
return ELF64_R_TYPE( info );
}
static int get_r_sym( Elf_Xword info ) { return ELF64_R_SYM( info ); }
static int get_r_type( Elf_Xword info ) { return ELF64_R_TYPE( info ); }
};
template<> struct get_sym_and_type< Elf64_Rela >
template <> struct get_sym_and_type<Elf64_Rela>
{
static int get_r_sym( Elf_Xword info )
{
return ELF64_R_SYM( info );
}
static int get_r_type( Elf_Xword info )
{
return ELF64_R_TYPE( info );
}
static int get_r_sym( Elf_Xword info ) { return ELF64_R_SYM( info ); }
static int get_r_type( Elf_Xword info ) { return ELF64_R_TYPE( info ); }
};
//------------------------------------------------------------------------------
template< class S >
class relocation_section_accessor_template
template <class S> class relocation_section_accessor_template
{
public:
//------------------------------------------------------------------------------
relocation_section_accessor_template( const elfio& elf_file_, S* section_ ) :
elf_file( elf_file_ ),
relocation_section( section_ )
//------------------------------------------------------------------------------
relocation_section_accessor_template( const elfio& elf_file_, S* section_ )
: elf_file( elf_file_ ), relocation_section( section_ )
{
}
//------------------------------------------------------------------------------
Elf_Xword
get_entries_num() const
//------------------------------------------------------------------------------
Elf_Xword get_entries_num() const
{
Elf_Xword nRet = 0;
if ( 0 != relocation_section->get_entry_size() ) {
nRet = relocation_section->get_size() / relocation_section->get_entry_size();
nRet = relocation_section->get_size() /
relocation_section->get_entry_size();
}
return nRet;
}
//------------------------------------------------------------------------------
bool
get_entry( Elf_Xword index,
//------------------------------------------------------------------------------
bool get_entry( Elf_Xword index,
Elf64_Addr& offset,
Elf_Word& symbol,
Elf_Word& type,
@ -111,31 +95,30 @@ class relocation_section_accessor_template
if ( elf_file.get_class() == ELFCLASS32 ) {
if ( SHT_REL == relocation_section->get_type() ) {
generic_get_entry_rel< Elf32_Rel >( index, offset, symbol,
type, addend );
generic_get_entry_rel<Elf32_Rel>( index, offset, symbol, type,
addend );
}
else if ( SHT_RELA == relocation_section->get_type() ) {
generic_get_entry_rela< Elf32_Rela >( index, offset, symbol,
type, addend );
generic_get_entry_rela<Elf32_Rela>( index, offset, symbol, type,
addend );
}
}
else {
if ( SHT_REL == relocation_section->get_type() ) {
generic_get_entry_rel< Elf64_Rel >( index, offset, symbol,
type, addend );
generic_get_entry_rel<Elf64_Rel>( index, offset, symbol, type,
addend );
}
else if ( SHT_RELA == relocation_section->get_type() ) {
generic_get_entry_rela< Elf64_Rela >( index, offset, symbol,
type, addend );
generic_get_entry_rela<Elf64_Rela>( index, offset, symbol, type,
addend );
}
}
return true;
}
//------------------------------------------------------------------------------
bool
get_entry( Elf_Xword index,
//------------------------------------------------------------------------------
bool get_entry( Elf_Xword index,
Elf64_Addr& offset,
Elf64_Addr& symbolValue,
std::string& symbolName,
@ -154,9 +137,10 @@ class relocation_section_accessor_template
Elf_Half section;
unsigned char other;
symbol_section_accessor symbols( elf_file, elf_file.sections[get_symbol_table_index()] );
ret = ret && symbols.get_symbol( symbol, symbolName, symbolValue,
size, bind, symbolType, section, other );
symbol_section_accessor symbols(
elf_file, elf_file.sections[get_symbol_table_index()] );
ret = ret && symbols.get_symbol( symbol, symbolName, symbolValue, size,
bind, symbolType, section, other );
if ( ret ) { // Was it successful?
switch ( type ) {
@ -201,79 +185,80 @@ class relocation_section_accessor_template
}
//------------------------------------------------------------------------------
bool
set_entry(Elf_Xword index,
bool set_entry( Elf_Xword index,
Elf64_Addr offset,
Elf_Word symbol,
Elf_Word type,
Elf_Sxword addend)
Elf_Sxword addend )
{
if (index >= get_entries_num()) { // Is index valid
if ( index >= get_entries_num() ) { // Is index valid
return false;
}
if (elf_file.get_class() == ELFCLASS32) {
if (SHT_REL == relocation_section->get_type()) {
generic_set_entry_rel<Elf32_Rel>(index, offset, symbol, type, addend);
if ( elf_file.get_class() == ELFCLASS32 ) {
if ( SHT_REL == relocation_section->get_type() ) {
generic_set_entry_rel<Elf32_Rel>( index, offset, symbol, type,
addend );
}
else if (SHT_RELA == relocation_section->get_type()) {
generic_set_entry_rela<Elf32_Rela>(index, offset, symbol, type, addend);
else if ( SHT_RELA == relocation_section->get_type() ) {
generic_set_entry_rela<Elf32_Rela>( index, offset, symbol, type,
addend );
}
}
else {
if (SHT_REL == relocation_section->get_type()) {
generic_set_entry_rel<Elf64_Rel>(index, offset, symbol, type, addend);
if ( SHT_REL == relocation_section->get_type() ) {
generic_set_entry_rel<Elf64_Rel>( index, offset, symbol, type,
addend );
}
else if (SHT_RELA == relocation_section->get_type()) {
generic_set_entry_rela<Elf64_Rela>(index, offset, symbol, type, addend);
else if ( SHT_RELA == relocation_section->get_type() ) {
generic_set_entry_rela<Elf64_Rela>( index, offset, symbol, type,
addend );
}
}
return true;
}
//------------------------------------------------------------------------------
void
add_entry( Elf64_Addr offset, Elf_Xword info )
//------------------------------------------------------------------------------
void add_entry( Elf64_Addr offset, Elf_Xword info )
{
if ( elf_file.get_class() == ELFCLASS32 ) {
generic_add_entry< Elf32_Rel >( offset, info );
generic_add_entry<Elf32_Rel>( offset, info );
}
else {
generic_add_entry< Elf64_Rel >( offset, info );
generic_add_entry<Elf64_Rel>( offset, info );
}
}
//------------------------------------------------------------------------------
void
add_entry( Elf64_Addr offset, Elf_Word symbol, unsigned char type )
//------------------------------------------------------------------------------
void add_entry( Elf64_Addr offset, Elf_Word symbol, unsigned char type )
{
Elf_Xword info;
if ( elf_file.get_class() == ELFCLASS32 ) {
info = ELF32_R_INFO( (Elf_Xword)symbol, type );
}
else {
info = ELF64_R_INFO((Elf_Xword)symbol, type );
info = ELF64_R_INFO( (Elf_Xword)symbol, type );
}
add_entry( offset, info );
}
//------------------------------------------------------------------------------
void
add_entry( Elf64_Addr offset, Elf_Xword info, Elf_Sxword addend )
//------------------------------------------------------------------------------
void add_entry( Elf64_Addr offset, Elf_Xword info, Elf_Sxword addend )
{
if ( elf_file.get_class() == ELFCLASS32 ) {
generic_add_entry< Elf32_Rela >( offset, info, addend );
generic_add_entry<Elf32_Rela>( offset, info, addend );
}
else {
generic_add_entry< Elf64_Rela >( offset, info, addend );
generic_add_entry<Elf64_Rela>( offset, info, addend );
}
}
//------------------------------------------------------------------------------
void
add_entry( Elf64_Addr offset, Elf_Word symbol, unsigned char type,
//------------------------------------------------------------------------------
void add_entry( Elf64_Addr offset,
Elf_Word symbol,
unsigned char type,
Elf_Sxword addend )
{
Elf_Xword info;
@ -287,9 +272,8 @@ class relocation_section_accessor_template
add_entry( offset, info, addend );
}
//------------------------------------------------------------------------------
void
add_entry( string_section_accessor str_writer,
//------------------------------------------------------------------------------
void add_entry( string_section_accessor str_writer,
const char* str,
symbol_section_accessor sym_writer,
Elf64_Addr value,
@ -307,40 +291,34 @@ class relocation_section_accessor_template
}
//------------------------------------------------------------------------------
void
swap_symbols(Elf_Xword first, Elf_Xword second)
void swap_symbols( Elf_Xword first, Elf_Xword second )
{
Elf64_Addr offset;
Elf_Word symbol;
Elf_Word rtype;
Elf_Sxword addend;
for (Elf_Word i = 0; i < get_entries_num(); i++)
{
get_entry(i, offset, symbol, rtype, addend);
if (symbol == first)
{
set_entry(i, offset, (Elf_Word)second, rtype, addend);
for ( Elf_Word i = 0; i < get_entries_num(); i++ ) {
get_entry( i, offset, symbol, rtype, addend );
if ( symbol == first ) {
set_entry( i, offset, (Elf_Word)second, rtype, addend );
}
if (symbol == second)
{
set_entry(i, offset, (Elf_Word)first, rtype, addend);
if ( symbol == second ) {
set_entry( i, offset, (Elf_Word)first, rtype, addend );
}
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
//------------------------------------------------------------------------------
Elf_Half
get_symbol_table_index() const
//------------------------------------------------------------------------------
Elf_Half get_symbol_table_index() const
{
return (Elf_Half)relocation_section->get_link();
}
//------------------------------------------------------------------------------
template< class T >
void
generic_get_entry_rel( Elf_Xword index,
//------------------------------------------------------------------------------
template <class T>
void generic_get_entry_rel( Elf_Xword index,
Elf64_Addr& offset,
Elf_Word& symbol,
Elf_Word& type,
@ -358,10 +336,9 @@ class relocation_section_accessor_template
addend = 0;
}
//------------------------------------------------------------------------------
template< class T >
void
generic_get_entry_rela( Elf_Xword index,
//------------------------------------------------------------------------------
template <class T>
void generic_get_entry_rela( Elf_Xword index,
Elf64_Addr& offset,
Elf_Word& symbol,
Elf_Word& type,
@ -381,60 +358,59 @@ class relocation_section_accessor_template
//------------------------------------------------------------------------------
template <class T>
void
generic_set_entry_rel(Elf_Xword index,
void generic_set_entry_rel( Elf_Xword index,
Elf64_Addr offset,
Elf_Word symbol,
Elf_Word type,
Elf_Sxword)
Elf_Sxword )
{
const endianess_convertor &convertor = elf_file.get_convertor();
const endianess_convertor& convertor = elf_file.get_convertor();
T *pEntry = const_cast<T *>(reinterpret_cast<const T *>(relocation_section->get_data() +
index * relocation_section->get_entry_size()));
T* pEntry = const_cast<T*>( reinterpret_cast<const T*>(
relocation_section->get_data() +
index * relocation_section->get_entry_size() ) );
if (elf_file.get_class() == ELFCLASS32) {
pEntry->r_info = ELF32_R_INFO((Elf_Xword)symbol, type);
if ( elf_file.get_class() == ELFCLASS32 ) {
pEntry->r_info = ELF32_R_INFO( (Elf_Xword)symbol, type );
}
else {
pEntry->r_info = ELF64_R_INFO((Elf_Xword)symbol, type);
pEntry->r_info = ELF64_R_INFO( (Elf_Xword)symbol, type );
}
pEntry->r_offset = offset;
pEntry->r_offset = convertor(pEntry->r_offset);
pEntry->r_info = convertor(pEntry->r_info);
pEntry->r_offset = convertor( pEntry->r_offset );
pEntry->r_info = convertor( pEntry->r_info );
}
//------------------------------------------------------------------------------
template <class T>
void
generic_set_entry_rela(Elf_Xword index,
void generic_set_entry_rela( Elf_Xword index,
Elf64_Addr offset,
Elf_Word symbol,
Elf_Word type,
Elf_Sxword addend)
Elf_Sxword addend )
{
const endianess_convertor &convertor = elf_file.get_convertor();
const endianess_convertor& convertor = elf_file.get_convertor();
T *pEntry = const_cast<T *>(reinterpret_cast<const T *>(relocation_section->get_data() +
index * relocation_section->get_entry_size()));
T* pEntry = const_cast<T*>( reinterpret_cast<const T*>(
relocation_section->get_data() +
index * relocation_section->get_entry_size() ) );
if (elf_file.get_class() == ELFCLASS32) {
pEntry->r_info = ELF32_R_INFO((Elf_Xword)symbol, type);
if ( elf_file.get_class() == ELFCLASS32 ) {
pEntry->r_info = ELF32_R_INFO( (Elf_Xword)symbol, type );
}
else {
pEntry->r_info = ELF64_R_INFO((Elf_Xword)symbol, type);
pEntry->r_info = ELF64_R_INFO( (Elf_Xword)symbol, type );
}
pEntry->r_offset = offset;
pEntry->r_addend = addend;
pEntry->r_offset = convertor(pEntry->r_offset);
pEntry->r_info = convertor(pEntry->r_info);
pEntry->r_addend = convertor(pEntry->r_addend);
pEntry->r_offset = convertor( pEntry->r_offset );
pEntry->r_info = convertor( pEntry->r_info );
pEntry->r_addend = convertor( pEntry->r_addend );
}
//------------------------------------------------------------------------------
template< class T >
void
generic_add_entry( Elf64_Addr offset, Elf_Xword info )
//------------------------------------------------------------------------------
template <class T>
void generic_add_entry( Elf64_Addr offset, Elf_Xword info )
{
const endianess_convertor& convertor = elf_file.get_convertor();
@ -444,11 +420,12 @@ class relocation_section_accessor_template
entry.r_offset = convertor( entry.r_offset );
entry.r_info = convertor( entry.r_info );
relocation_section->append_data( reinterpret_cast<char*>( &entry ), sizeof( entry ) );
relocation_section->append_data( reinterpret_cast<char*>( &entry ),
sizeof( entry ) );
}
//------------------------------------------------------------------------------
template< class T >
//------------------------------------------------------------------------------
template <class T>
void
generic_add_entry( Elf64_Addr offset, Elf_Xword info, Elf_Sxword addend )
{
@ -462,17 +439,20 @@ class relocation_section_accessor_template
entry.r_info = convertor( entry.r_info );
entry.r_addend = convertor( entry.r_addend );
relocation_section->append_data( reinterpret_cast<char*>( &entry ), sizeof( entry ) );
relocation_section->append_data( reinterpret_cast<char*>( &entry ),
sizeof( entry ) );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
const elfio& elf_file;
S* relocation_section;
};
using relocation_section_accessor = relocation_section_accessor_template<section>;
using const_relocation_section_accessor = relocation_section_accessor_template<const section>;
using relocation_section_accessor =
relocation_section_accessor_template<section>;
using const_relocation_section_accessor =
relocation_section_accessor_template<const section>;
} // namespace ELFIO

190
elfio/elfio_section.hpp
View File

@ -31,10 +31,11 @@ namespace ELFIO {
class section
{
friend class elfio;
public:
virtual ~section() {};
ELFIO_GET_ACCESS_DECL ( Elf_Half, index );
public:
virtual ~section(){};
ELFIO_GET_ACCESS_DECL( Elf_Half, index );
ELFIO_GET_SET_ACCESS_DECL( std::string, name );
ELFIO_GET_SET_ACCESS_DECL( Elf_Word, type );
ELFIO_GET_SET_ACCESS_DECL( Elf_Xword, flags );
@ -45,7 +46,7 @@ class section
ELFIO_GET_SET_ACCESS_DECL( Elf64_Addr, address );
ELFIO_GET_SET_ACCESS_DECL( Elf_Xword, size );
ELFIO_GET_SET_ACCESS_DECL( Elf_Word, name_string_offset );
ELFIO_GET_ACCESS_DECL ( Elf64_Off, offset );
ELFIO_GET_ACCESS_DECL( Elf64_Off, offset );
virtual const char* get_data() const = 0;
virtual void set_data( const char* pData, Elf_Word size ) = 0;
@ -55,27 +56,26 @@ class section
virtual size_t get_stream_size() const = 0;
virtual void set_stream_size( size_t value ) = 0;
protected:
protected:
ELFIO_SET_ACCESS_DECL( Elf64_Off, offset );
ELFIO_SET_ACCESS_DECL( Elf_Half, index );
virtual void load( std::istream& stream,
std::streampos header_offset ) = 0;
virtual void load( std::istream& stream, std::streampos header_offset ) = 0;
virtual void save( std::ostream& stream,
std::streampos header_offset,
std::streampos data_offset ) = 0;
virtual bool is_address_initialized() const = 0;
};
template< class T >
class section_impl : public section
template <class T> class section_impl : public section
{
public:
//------------------------------------------------------------------------------
section_impl( const endianess_convertor* convertor_ ) : convertor( convertor_ )
//------------------------------------------------------------------------------
section_impl( const endianess_convertor* convertor_ )
: convertor( convertor_ )
{
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ), '\0' );
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ),
'\0' );
is_address_set = false;
data = 0;
data_size = 0;
@ -83,13 +83,10 @@ class section_impl : public section
stream_size = 0;
}
//------------------------------------------------------------------------------
~section_impl()
{
delete [] data;
}
//------------------------------------------------------------------------------
~section_impl() { delete[] data; }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Section info functions
ELFIO_GET_SET_ACCESS( Elf_Word, type, header.sh_type );
ELFIO_GET_SET_ACCESS( Elf_Xword, flags, header.sh_flags );
@ -99,62 +96,40 @@ class section_impl : public section
ELFIO_GET_SET_ACCESS( Elf_Xword, addr_align, header.sh_addralign );
ELFIO_GET_SET_ACCESS( Elf_Xword, entry_size, header.sh_entsize );
ELFIO_GET_SET_ACCESS( Elf_Word, name_string_offset, header.sh_name );
ELFIO_GET_ACCESS ( Elf64_Addr, address, header.sh_addr );
ELFIO_GET_ACCESS( Elf64_Addr, address, header.sh_addr );
//------------------------------------------------------------------------------
Elf_Half
get_index() const
{
return index;
}
//------------------------------------------------------------------------------
Elf_Half get_index() const { return index; }
//------------------------------------------------------------------------------
std::string get_name() const { return name; }
//------------------------------------------------------------------------------
std::string
get_name() const
{
return name;
}
//------------------------------------------------------------------------------
void set_name( std::string name_ ) { name = name_; }
//------------------------------------------------------------------------------
void
set_name( std::string name_ )
{
name = name_;
}
//------------------------------------------------------------------------------
void
set_address( Elf64_Addr value )
//------------------------------------------------------------------------------
void set_address( Elf64_Addr value )
{
header.sh_addr = value;
header.sh_addr = (*convertor)( header.sh_addr );
header.sh_addr = ( *convertor )( header.sh_addr );
is_address_set = true;
}
//------------------------------------------------------------------------------
bool
is_address_initialized() const
{
return is_address_set;
}
//------------------------------------------------------------------------------
bool is_address_initialized() const { return is_address_set; }
//------------------------------------------------------------------------------
const char*
get_data() const
{
return data;
}
//------------------------------------------------------------------------------
const char* get_data() const { return data; }
//------------------------------------------------------------------------------
void
set_data( const char* raw_data, Elf_Word size )
//------------------------------------------------------------------------------
void set_data( const char* raw_data, Elf_Word size )
{
if ( get_type() != SHT_NOBITS ) {
delete [] data;
delete[] data;
try {
data = new char[size];
} catch (const std::bad_alloc&) {
}
catch ( const std::bad_alloc& ) {
data = 0;
data_size = 0;
size = 0;
@ -168,34 +143,34 @@ class section_impl : public section
set_size( size );
}
//------------------------------------------------------------------------------
void
set_data( const std::string& str_data )
//------------------------------------------------------------------------------
void set_data( const std::string& str_data )
{
return set_data( str_data.c_str(), (Elf_Word)str_data.size() );
}
//------------------------------------------------------------------------------
void
append_data( const char* raw_data, Elf_Word size )
//------------------------------------------------------------------------------
void append_data( const char* raw_data, Elf_Word size )
{
if ( get_type() != SHT_NOBITS ) {
if ( get_size() + size < data_size ) {
std::copy( raw_data, raw_data + size, data + get_size() );
}
else {
data_size = 2*( data_size + size);
data_size = 2 * ( data_size + size );
char* new_data;
try {
new_data = new char[data_size];
} catch (const std::bad_alloc&) {
}
catch ( const std::bad_alloc& ) {
new_data = 0;
size = 0;
}
if ( 0 != new_data ) {
std::copy( data, data + get_size(), new_data );
std::copy( raw_data, raw_data + size, new_data + get_size() );
delete [] data;
std::copy( raw_data, raw_data + size,
new_data + get_size() );
delete[] data;
data = new_data;
}
}
@ -203,50 +178,45 @@ class section_impl : public section
}
}
//------------------------------------------------------------------------------
void
append_data( const std::string& str_data )
//------------------------------------------------------------------------------
void append_data( const std::string& str_data )
{
return append_data( str_data.c_str(), (Elf_Word)str_data.size() );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
protected:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
ELFIO_GET_SET_ACCESS( Elf64_Off, offset, header.sh_offset );
//------------------------------------------------------------------------------
void
set_index( Elf_Half value )
{
index = value;
}
//------------------------------------------------------------------------------
void set_index( Elf_Half value ) { index = value; }
//------------------------------------------------------------------------------
void
load( std::istream& stream,
std::streampos header_offset )
//------------------------------------------------------------------------------
void load( std::istream& stream, std::streampos header_offset )
{
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ), '\0' );
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ),
'\0' );
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg( 0, stream.end );
set_stream_size( stream.tellg() );
stream.seekg( header_offset );
stream.read( reinterpret_cast<char*>( &header ), sizeof( header ) );
Elf_Xword size = get_size();
if ( 0 == data && SHT_NULL != get_type() && SHT_NOBITS != get_type() && size < get_stream_size()) {
if ( 0 == data && SHT_NULL != get_type() && SHT_NOBITS != get_type() &&
size < get_stream_size() ) {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
}
catch ( const std::bad_alloc& ) {
data = 0;
data_size = 0;
}
if ( ( 0 != size ) && ( 0 != data ) ) {
stream.seekg( (*convertor)( header.sh_offset ) );
stream.seekg( ( *convertor )( header.sh_offset ) );
stream.read( data, size );
data[size] = 0; // Ensure data is ended with 0 to avoid oob read
data_size = size;
@ -254,15 +224,14 @@ class section_impl : public section
}
}
//------------------------------------------------------------------------------
void
save( std::ostream& stream,
//------------------------------------------------------------------------------
void save( std::ostream& stream,
std::streampos header_offset,
std::streampos data_offset )
{
if ( 0 != get_index() ) {
header.sh_offset = data_offset;
header.sh_offset = (*convertor)( header.sh_offset );
header.sh_offset = ( *convertor )( header.sh_offset );
}
save_header( stream, header_offset );
@ -272,39 +241,30 @@ class section_impl : public section
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
//------------------------------------------------------------------------------
void
save_header( std::ostream& stream,
std::streampos header_offset ) const
//------------------------------------------------------------------------------
void save_header( std::ostream& stream, std::streampos header_offset ) const
{
stream.seekp( header_offset );
stream.write( reinterpret_cast<const char*>( &header ), sizeof( header ) );
stream.write( reinterpret_cast<const char*>( &header ),
sizeof( header ) );
}
//------------------------------------------------------------------------------
void
save_data( std::ostream& stream,
std::streampos data_offset ) const
//------------------------------------------------------------------------------
void save_data( std::ostream& stream, std::streampos data_offset ) const
{
stream.seekp( data_offset );
stream.write( get_data(), get_size() );
}
//------------------------------------------------------------------------------
size_t get_stream_size() const
{
return stream_size;
}
size_t get_stream_size() const { return stream_size; }
//------------------------------------------------------------------------------
void set_stream_size(size_t value)
{
stream_size = value;
}
void set_stream_size( size_t value ) { stream_size = value; }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
T header;
Elf_Half index;

140
elfio/elfio_segment.hpp
View File

@ -31,10 +31,11 @@ namespace ELFIO {
class segment
{
friend class elfio;
public:
virtual ~segment() {};
ELFIO_GET_ACCESS_DECL ( Elf_Half, index );
public:
virtual ~segment(){};
ELFIO_GET_ACCESS_DECL( Elf_Half, index );
ELFIO_GET_SET_ACCESS_DECL( Elf_Word, type );
ELFIO_GET_SET_ACCESS_DECL( Elf_Word, flags );
ELFIO_GET_SET_ACCESS_DECL( Elf_Xword, align );
@ -46,7 +47,8 @@ class segment
virtual const char* get_data() const = 0;
virtual Elf_Half add_section_index( Elf_Half index, Elf_Xword addr_align ) = 0;
virtual Elf_Half add_section_index( Elf_Half index,
Elf_Xword addr_align ) = 0;
virtual Elf_Half get_sections_num() const = 0;
virtual Elf_Half get_section_index_at( Elf_Half num ) const = 0;
virtual bool is_offset_initialized() const = 0;
@ -57,31 +59,27 @@ class segment
virtual const std::vector<Elf_Half>& get_sections() const = 0;
virtual void load( std::istream& stream, std::streampos header_offset ) = 0;
virtual void save( std::ostream& stream, std::streampos header_offset,
virtual void save( std::ostream& stream,
std::streampos header_offset,
std::streampos data_offset ) = 0;
};
//------------------------------------------------------------------------------
template< class T >
class segment_impl : public segment
template <class T> class segment_impl : public segment
{
public:
//------------------------------------------------------------------------------
segment_impl( endianess_convertor* convertor_ ) :
stream_size( 0 ), index( 0 ), data( 0 ), convertor( convertor_ )
//------------------------------------------------------------------------------
segment_impl( endianess_convertor* convertor_ )
: stream_size( 0 ), index( 0 ), data( 0 ), convertor( convertor_ )
{
is_offset_set = false;
std::fill_n( reinterpret_cast<char*>( &ph ), sizeof( ph ), '\0' );
}
//------------------------------------------------------------------------------
virtual ~segment_impl()
{
delete [] data;
}
//------------------------------------------------------------------------------
virtual ~segment_impl() { delete[] data; }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Section info functions
ELFIO_GET_SET_ACCESS( Elf_Word, type, ph.p_type );
ELFIO_GET_SET_ACCESS( Elf_Word, flags, ph.p_flags );
@ -93,37 +91,20 @@ class segment_impl : public segment
ELFIO_GET_ACCESS( Elf64_Off, offset, ph.p_offset );
size_t stream_size;
//------------------------------------------------------------------------------
size_t
get_stream_size() const
{
return stream_size;
}
//------------------------------------------------------------------------------
size_t get_stream_size() const { return stream_size; }
//------------------------------------------------------------------------------
void
set_stream_size(size_t value)
{
stream_size = value;
}
//------------------------------------------------------------------------------
void set_stream_size( size_t value ) { stream_size = value; }
//------------------------------------------------------------------------------
Elf_Half
get_index() const
{
return index;
}
//------------------------------------------------------------------------------
Elf_Half get_index() const { return index; }
//------------------------------------------------------------------------------
const char*
get_data() const
{
return data;
}
//------------------------------------------------------------------------------
const char* get_data() const { return data; }
//------------------------------------------------------------------------------
Elf_Half
add_section_index( Elf_Half sec_index, Elf_Xword addr_align )
//------------------------------------------------------------------------------
Elf_Half add_section_index( Elf_Half sec_index, Elf_Xword addr_align )
{
sections.push_back( sec_index );
if ( addr_align > get_align() ) {
@ -133,73 +114,53 @@ class segment_impl : public segment
return (Elf_Half)sections.size();
}
//------------------------------------------------------------------------------
Elf_Half
get_sections_num() const
{
return (Elf_Half)sections.size();
}
//------------------------------------------------------------------------------
Elf_Half get_sections_num() const { return (Elf_Half)sections.size(); }
//------------------------------------------------------------------------------
Elf_Half
get_section_index_at( Elf_Half num ) const
//------------------------------------------------------------------------------
Elf_Half get_section_index_at( Elf_Half num ) const
{
if ( num < sections.size() ) {
return sections[num];
}
return Elf_Half(-1);
return Elf_Half( -1 );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
protected:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void
set_offset( Elf64_Off value )
//------------------------------------------------------------------------------
void set_offset( Elf64_Off value )
{
ph.p_offset = value;
ph.p_offset = (*convertor)( ph.p_offset );
ph.p_offset = ( *convertor )( ph.p_offset );
is_offset_set = true;
}
//------------------------------------------------------------------------------
bool
is_offset_initialized() const
{
return is_offset_set;
}
//------------------------------------------------------------------------------
bool is_offset_initialized() const { return is_offset_set; }
//------------------------------------------------------------------------------
const std::vector<Elf_Half>&
get_sections() const
{
return sections;
}
//------------------------------------------------------------------------------
const std::vector<Elf_Half>& get_sections() const { return sections; }
//------------------------------------------------------------------------------
void
set_index( Elf_Half value )
{
index = value;
}
//------------------------------------------------------------------------------
void set_index( Elf_Half value ) { index = value; }
//------------------------------------------------------------------------------
void
load( std::istream& stream,
std::streampos header_offset )
//------------------------------------------------------------------------------
void load( std::istream& stream, std::streampos header_offset )
{
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg( 0, stream.end );
set_stream_size( stream.tellg() );
stream.seekg( header_offset );
stream.read( reinterpret_cast<char*>( &ph ), sizeof( ph ) );
is_offset_set = true;
if ( PT_NULL != get_type() && 0 != get_file_size() ) {
stream.seekg( (*convertor)( ph.p_offset ) );
stream.seekg( ( *convertor )( ph.p_offset ) );
Elf_Xword size = get_file_size();
if ( size > get_stream_size() ) {
@ -208,7 +169,8 @@ class segment_impl : public segment
else {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
}
catch ( const std::bad_alloc& ) {
data = 0;
}
@ -220,18 +182,18 @@ class segment_impl : public segment
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void save( std::ostream& stream,
std::streampos header_offset,
std::streampos data_offset )
{
ph.p_offset = data_offset;
ph.p_offset = (*convertor)(ph.p_offset);
ph.p_offset = ( *convertor )( ph.p_offset );
stream.seekp( header_offset );
stream.write( reinterpret_cast<const char*>( &ph ), sizeof( ph ) );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
T ph;
Elf_Half index;

36
elfio/elfio_strings.hpp
View File

@ -30,20 +30,16 @@ THE SOFTWARE.
namespace ELFIO {
//------------------------------------------------------------------------------
template< class S >
class string_section_accessor_template
template <class S> class string_section_accessor_template
{
public:
//------------------------------------------------------------------------------
string_section_accessor_template( S* section_ ) :
string_section( section_ )
//------------------------------------------------------------------------------
string_section_accessor_template( S* section_ ) : string_section( section_ )
{
}
//------------------------------------------------------------------------------
const char*
get_string( Elf_Word index ) const
//------------------------------------------------------------------------------
const char* get_string( Elf_Word index ) const
{
if ( string_section ) {
if ( index < string_section->get_size() ) {
@ -57,14 +53,12 @@ class string_section_accessor_template
return 0;
}
//------------------------------------------------------------------------------
Elf_Word
add_string( const char* str )
//------------------------------------------------------------------------------
Elf_Word add_string( const char* str )
{
Elf_Word current_position = 0;
if (string_section) {
if ( string_section ) {
// Strings are addeded to the end of the current section data
current_position = (Elf_Word)string_section->get_size();
@ -73,27 +67,27 @@ class string_section_accessor_template
string_section->append_data( &empty_string, 1 );
current_position++;
}
string_section->append_data( str, (Elf_Word)std::strlen( str ) + 1 );
string_section->append_data( str,
(Elf_Word)std::strlen( str ) + 1 );
}
return current_position;
}
//------------------------------------------------------------------------------
Elf_Word
add_string( const std::string& str )
//------------------------------------------------------------------------------
Elf_Word add_string( const std::string& str )
{
return add_string( str.c_str() );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
S* string_section;
};
using string_section_accessor = string_section_accessor_template<section>;
using const_string_section_accessor = string_section_accessor_template<const section>;
using const_string_section_accessor =
string_section_accessor_template<const section>;
} // namespace ELFIO

270
elfio/elfio_symbols.hpp
View File

@ -26,33 +26,31 @@ THE SOFTWARE.
namespace ELFIO {
//------------------------------------------------------------------------------
template< class S >
class symbol_section_accessor_template
template <class S> class symbol_section_accessor_template
{
public:
//------------------------------------------------------------------------------
symbol_section_accessor_template( const elfio& elf_file_, S* symbol_section_ ) :
elf_file( elf_file_ ),
symbol_section( symbol_section_ )
//------------------------------------------------------------------------------
symbol_section_accessor_template( const elfio& elf_file_,
S* symbol_section_ )
: elf_file( elf_file_ ), symbol_section( symbol_section_ )
{
find_hash_section();
}
//------------------------------------------------------------------------------
Elf_Xword
get_symbols_num() const
//------------------------------------------------------------------------------
Elf_Xword get_symbols_num() const
{
Elf_Xword nRet = 0;
if ( 0 != symbol_section->get_entry_size() ) {
nRet = symbol_section->get_size() / symbol_section->get_entry_size();
nRet =
symbol_section->get_size() / symbol_section->get_entry_size();
}
return nRet;
}
//------------------------------------------------------------------------------
bool
get_symbol( Elf_Xword index,
//------------------------------------------------------------------------------
bool get_symbol( Elf_Xword index,
std::string& name,
Elf64_Addr& value,
Elf_Xword& size,
@ -75,9 +73,8 @@ class symbol_section_accessor_template
return ret;
}
//------------------------------------------------------------------------------
bool
get_symbol( const std::string& name,
//------------------------------------------------------------------------------
bool get_symbol( const std::string& name,
Elf64_Addr& value,
Elf_Xword& size,
unsigned char& bind,
@ -93,13 +90,16 @@ class symbol_section_accessor_template
sizeof( Elf_Word ) );
Elf_Word val = elf_hash( (const unsigned char*)name.c_str() );
Elf_Word y = *(const Elf_Word*)( hash_section->get_data() +
( 2 + val % nbucket ) * sizeof( Elf_Word ) );
( 2 + val % nbucket ) *
sizeof( Elf_Word ) );
std::string str;
get_symbol( y, str, value, size, bind, type, section_index, other );
while ( str != name && STN_UNDEF != y && y < nchain ) {
y = *(const Elf_Word*)( hash_section->get_data() +
( 2 + nbucket + y ) * sizeof( Elf_Word ) );
get_symbol( y, str, value, size, bind, type, section_index, other );
( 2 + nbucket + y ) *
sizeof( Elf_Word ) );
get_symbol( y, str, value, size, bind, type, section_index,
other );
}
if ( str == name ) {
ret = true;
@ -109,7 +109,7 @@ class symbol_section_accessor_template
for ( Elf_Xword i = 0; i < get_symbols_num() && !ret; i++ ) {
std::string symbol_name;
if ( get_symbol( i, symbol_name, value, size, bind, type,
section_index, other) ) {
section_index, other ) ) {
if ( symbol_name == name ) {
ret = true;
}
@ -121,8 +121,7 @@ class symbol_section_accessor_template
}
//------------------------------------------------------------------------------
bool
get_symbol( const Elf64_Addr& value,
bool get_symbol( const Elf64_Addr& value,
std::string& name,
Elf_Xword& size,
unsigned char& bind,
@ -131,7 +130,6 @@ class symbol_section_accessor_template
unsigned char& other ) const
{
const endianess_convertor& convertor = elf_file.get_convertor();
Elf_Xword idx = 0;
@ -139,26 +137,34 @@ class symbol_section_accessor_template
Elf64_Addr v = 0;
if ( elf_file.get_class() == ELFCLASS32 ) {
match = generic_search_symbols<Elf32_Sym>([&](const Elf32_Sym* sym) {
return convertor(sym->st_value) == value;
}, idx);
} else {
match = generic_search_symbols<Elf64_Sym>([&](const Elf64_Sym* sym) {
return convertor(sym->st_value) == value;
}, idx);
match = generic_search_symbols<Elf32_Sym>(
[&]( const Elf32_Sym* sym ) {
return convertor( sym->st_value ) == value;
},
idx );
}
else {
match = generic_search_symbols<Elf64_Sym>(
[&]( const Elf64_Sym* sym ) {
return convertor( sym->st_value ) == value;
},
idx );
}
if ( match ) {
return get_symbol( idx, name, v, size, bind, type, section_index, other );
return get_symbol( idx, name, v, size, bind, type, section_index,
other );
}
return false;
}
//------------------------------------------------------------------------------
Elf_Word
add_symbol( Elf_Word name, Elf64_Addr value, Elf_Xword size,
unsigned char info, unsigned char other,
//------------------------------------------------------------------------------
Elf_Word add_symbol( Elf_Word name,
Elf64_Addr value,
Elf_Xword size,
unsigned char info,
unsigned char other,
Elf_Half shndx )
{
Elf_Word nRet;
@ -173,68 +179,78 @@ class symbol_section_accessor_template
}
if ( elf_file.get_class() == ELFCLASS32 ) {
nRet = generic_add_symbol<Elf32_Sym>( name, value, size, info, other,
shndx );
nRet = generic_add_symbol<Elf32_Sym>( name, value, size, info,
other, shndx );
}
else {
nRet = generic_add_symbol<Elf64_Sym>( name, value, size, info, other,
shndx );
nRet = generic_add_symbol<Elf64_Sym>( name, value, size, info,
other, shndx );
}
return nRet;
}
//------------------------------------------------------------------------------
Elf_Word
add_symbol( Elf_Word name, Elf64_Addr value, Elf_Xword size,
unsigned char bind, unsigned char type, unsigned char other,
//------------------------------------------------------------------------------
Elf_Word add_symbol( Elf_Word name,
Elf64_Addr value,
Elf_Xword size,
unsigned char bind,
unsigned char type,
unsigned char other,
Elf_Half shndx )
{
return add_symbol( name, value, size, ELF_ST_INFO( bind, type ), other, shndx );
return add_symbol( name, value, size, ELF_ST_INFO( bind, type ), other,
shndx );
}
//------------------------------------------------------------------------------
Elf_Word
add_symbol( string_section_accessor& pStrWriter, const char* str,
Elf64_Addr value, Elf_Xword size,
unsigned char info, unsigned char other,
//------------------------------------------------------------------------------
Elf_Word add_symbol( string_section_accessor& pStrWriter,
const char* str,
Elf64_Addr value,
Elf_Xword size,
unsigned char info,
unsigned char other,
Elf_Half shndx )
{
Elf_Word index = pStrWriter.add_string( str );
return add_symbol( index, value, size, info, other, shndx );
}
//------------------------------------------------------------------------------
Elf_Word
add_symbol( string_section_accessor& pStrWriter, const char* str,
Elf64_Addr value, Elf_Xword size,
unsigned char bind, unsigned char type, unsigned char other,
//------------------------------------------------------------------------------
Elf_Word add_symbol( string_section_accessor& pStrWriter,
const char* str,
Elf64_Addr value,
Elf_Xword size,
unsigned char bind,
unsigned char type,
unsigned char other,
Elf_Half shndx )
{
return add_symbol( pStrWriter, str, value, size, ELF_ST_INFO( bind, type ), other, shndx );
return add_symbol( pStrWriter, str, value, size,
ELF_ST_INFO( bind, type ), other, shndx );
}
//------------------------------------------------------------------------------
Elf_Xword
arrange_local_symbols(std::function<void(Elf_Xword first, Elf_Xword second)> func = nullptr)
//------------------------------------------------------------------------------
Elf_Xword arrange_local_symbols(
std::function<void( Elf_Xword first, Elf_Xword second )> func =
nullptr )
{
int nRet = 0;
if (elf_file.get_class() == ELFCLASS32) {
nRet = generic_arrange_local_symbols<Elf32_Sym>(func);
if ( elf_file.get_class() == ELFCLASS32 ) {
nRet = generic_arrange_local_symbols<Elf32_Sym>( func );
}
else {
nRet = generic_arrange_local_symbols<Elf64_Sym>(func);
nRet = generic_arrange_local_symbols<Elf64_Sym>( func );
}
return nRet;
}
//------------------------------------------------------------------------------
private :
//------------------------------------------------------------------------------
void
find_hash_section()
//------------------------------------------------------------------------------
private:
//------------------------------------------------------------------------------
void find_hash_section()
{
hash_section = 0;
hash_section_index = 0;
@ -248,24 +264,18 @@ class symbol_section_accessor_template
}
}
//------------------------------------------------------------------------------
Elf_Half
get_string_table_index() const
//------------------------------------------------------------------------------
Elf_Half get_string_table_index() const
{
return (Elf_Half)symbol_section->get_link();
}
//------------------------------------------------------------------------------
Elf_Half
get_hash_table_index() const
{
return hash_section_index;
}
//------------------------------------------------------------------------------
Elf_Half get_hash_table_index() const { return hash_section_index; }
//------------------------------------------------------------------------------
template< class T >
const T*
generic_get_symbol_ptr(Elf_Xword index) const {
//------------------------------------------------------------------------------
template <class T> const T* generic_get_symbol_ptr( Elf_Xword index ) const
{
if ( 0 != symbol_section->get_data() && index < get_symbols_num() ) {
const T* pSym = reinterpret_cast<const T*>(
symbol_section->get_data() +
@ -277,17 +287,18 @@ class symbol_section_accessor_template
return nullptr;
}
//------------------------------------------------------------------------------
template< class T >
bool
generic_search_symbols(std::function<bool(const T*)> match, Elf_Xword& idx) const {
for (Elf_Xword i = 0; i < get_symbols_num(); i++){
const T* symPtr = generic_get_symbol_ptr<T>(i);
//------------------------------------------------------------------------------
template <class T>
bool generic_search_symbols( std::function<bool( const T* )> match,
Elf_Xword& idx ) const
{
for ( Elf_Xword i = 0; i < get_symbols_num(); i++ ) {
const T* symPtr = generic_get_symbol_ptr<T>( i );
if (symPtr == nullptr)
if ( symPtr == nullptr )
return false;
if (match(symPtr)) {
if ( match( symPtr ) ) {
idx = i;
return true;
}
@ -296,13 +307,14 @@ class symbol_section_accessor_template
return false;
}
//------------------------------------------------------------------------------
template< class T >
bool
generic_get_symbol( Elf_Xword index,
std::string& name, Elf64_Addr& value,
//------------------------------------------------------------------------------
template <class T>
bool generic_get_symbol( Elf_Xword index,
std::string& name,
Elf64_Addr& value,
Elf_Xword& size,
unsigned char& bind, unsigned char& type,
unsigned char& bind,
unsigned char& type,
Elf_Half& section_index,
unsigned char& other ) const
{
@ -315,9 +327,11 @@ class symbol_section_accessor_template
const endianess_convertor& convertor = elf_file.get_convertor();
section* string_section = elf_file.sections[get_string_table_index()];
section* string_section =
elf_file.sections[get_string_table_index()];
string_section_accessor str_reader( string_section );
const char* pStr = str_reader.get_string( convertor( pSym->st_name ) );
const char* pStr =
str_reader.get_string( convertor( pSym->st_name ) );
if ( 0 != pStr ) {
name = pStr;
}
@ -334,11 +348,13 @@ class symbol_section_accessor_template
return ret;
}
//------------------------------------------------------------------------------
template< class T >
Elf_Word
generic_add_symbol( Elf_Word name, Elf64_Addr value, Elf_Xword size,
unsigned char info, unsigned char other,
//------------------------------------------------------------------------------
template <class T>
Elf_Word generic_add_symbol( Elf_Word name,
Elf64_Addr value,
Elf_Xword size,
unsigned char info,
unsigned char other,
Elf_Half shndx )
{
const endianess_convertor& convertor = elf_file.get_convertor();
@ -363,53 +379,50 @@ class symbol_section_accessor_template
//------------------------------------------------------------------------------
template <class T>
Elf_Xword
generic_arrange_local_symbols(std::function<void (Elf_Xword first, Elf_Xword second)> func)
Elf_Xword generic_arrange_local_symbols(
std::function<void( Elf_Xword first, Elf_Xword second )> func )
{
const endianess_convertor &convertor = elf_file.get_convertor();
const endianess_convertor& convertor = elf_file.get_convertor();
const Elf_Xword size = symbol_section->get_entry_size();
Elf_Xword first_not_local = 1; // Skip the first entry. It is always NOTYPE
Elf_Xword first_not_local =
1; // Skip the first entry. It is always NOTYPE
Elf_Xword current = 0;
Elf_Xword count = get_symbols_num();
while (true)
{
T *p1 = nullptr;
T *p2 = nullptr;
while ( true ) {
T* p1 = nullptr;
T* p2 = nullptr;
while (first_not_local < count)
{
p1 = const_cast<T *>(generic_get_symbol_ptr<T>(first_not_local));
if (ELF_ST_BIND(convertor(p1->st_info)) != STB_LOCAL)
while ( first_not_local < count ) {
p1 = const_cast<T*>(
generic_get_symbol_ptr<T>( first_not_local ) );
if ( ELF_ST_BIND( convertor( p1->st_info ) ) != STB_LOCAL )
break;
++first_not_local;
}
current = first_not_local + 1;
while (current < count)
{
p2 = const_cast<T *>(generic_get_symbol_ptr<T>(current));
if (ELF_ST_BIND(convertor(p2->st_info)) == STB_LOCAL)
while ( current < count ) {
p2 = const_cast<T*>( generic_get_symbol_ptr<T>( current ) );
if ( ELF_ST_BIND( convertor( p2->st_info ) ) == STB_LOCAL )
break;
++current;
}
if (first_not_local < count && current < count)
{
if (func)
func(first_not_local, current);
if ( first_not_local < count && current < count ) {
if ( func )
func( first_not_local, current );
// Swap the symbols
T tmp;
std::copy(p1, p1 + 1, &tmp);
std::copy(p2, p2 + 1, p1);
std::copy(&tmp, &tmp + 1, p2);
std::copy( p1, p1 + 1, &tmp );
std::copy( p2, p2 + 1, p1 );
std::copy( &tmp, &tmp + 1, p2 );
}
else
{
else {
// Update 'info' field of the section
symbol_section->set_info(first_not_local);
symbol_section->set_info( first_not_local );
break;
}
}
@ -419,7 +432,7 @@ class symbol_section_accessor_template
return first_not_local;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
const elfio& elf_file;
S* symbol_section;
@ -428,7 +441,8 @@ class symbol_section_accessor_template
};
using symbol_section_accessor = symbol_section_accessor_template<section>;
using const_symbol_section_accessor = symbol_section_accessor_template<const section>;
using const_symbol_section_accessor =
symbol_section_accessor_template<const section>;
} // namespace ELFIO

113
elfio/elfio_utils.hpp
View File

@ -24,29 +24,22 @@ THE SOFTWARE.
#define ELFIO_UTILS_HPP
#define ELFIO_GET_ACCESS( TYPE, NAME, FIELD ) \
TYPE get_##NAME() const \
{ \
return (*convertor)( FIELD ); \
}
TYPE get_##NAME() const { return ( *convertor )( FIELD ); }
#define ELFIO_SET_ACCESS( TYPE, NAME, FIELD ) \
void set_##NAME( TYPE value ) \
{ \
FIELD = value; \
FIELD = (*convertor)( FIELD ); \
FIELD = ( *convertor )( FIELD ); \
}
#define ELFIO_GET_SET_ACCESS( TYPE, NAME, FIELD ) \
TYPE get_##NAME() const \
{ \
return (*convertor)( FIELD ); \
} \
TYPE get_##NAME() const { return ( *convertor )( FIELD ); } \
void set_##NAME( TYPE value ) \
{ \
FIELD = value; \
FIELD = (*convertor)( FIELD ); \
FIELD = ( *convertor )( FIELD ); \
}
#define ELFIO_GET_ACCESS_DECL( TYPE, NAME ) \
virtual TYPE get_##NAME() const = 0
#define ELFIO_GET_ACCESS_DECL( TYPE, NAME ) virtual TYPE get_##NAME() const = 0
#define ELFIO_SET_ACCESS_DECL( TYPE, NAME ) \
virtual void set_##NAME( TYPE value ) = 0
@ -58,30 +51,25 @@ THE SOFTWARE.
namespace ELFIO {
//------------------------------------------------------------------------------
class endianess_convertor {
class endianess_convertor
{
public:
//------------------------------------------------------------------------------
endianess_convertor()
{
need_conversion = false;
}
//------------------------------------------------------------------------------
endianess_convertor() { need_conversion = false; }
//------------------------------------------------------------------------------
void
setup( unsigned char elf_file_encoding )
//------------------------------------------------------------------------------
void setup( unsigned char elf_file_encoding )
{
need_conversion = ( elf_file_encoding != get_host_encoding() );
}
//------------------------------------------------------------------------------
uint64_t
operator()( uint64_t value ) const
//------------------------------------------------------------------------------
uint64_t operator()( uint64_t value ) const
{
if ( !need_conversion ) {
return value;
}
value =
( ( value & 0x00000000000000FFull ) << 56 ) |
value = ( ( value & 0x00000000000000FFull ) << 56 ) |
( ( value & 0x000000000000FF00ull ) << 40 ) |
( ( value & 0x0000000000FF0000ull ) << 24 ) |
( ( value & 0x00000000FF000000ull ) << 8 ) |
@ -93,85 +81,67 @@ class endianess_convertor {
return value;
}
//------------------------------------------------------------------------------
int64_t
operator()( int64_t value ) const
//------------------------------------------------------------------------------
int64_t operator()( int64_t value ) const
{
if ( !need_conversion ) {
return value;
}
return (int64_t)(*this)( (uint64_t)value );
return ( int64_t )( *this )( (uint64_t)value );
}
//------------------------------------------------------------------------------
uint32_t
operator()( uint32_t value ) const
//------------------------------------------------------------------------------
uint32_t operator()( uint32_t value ) const
{
if ( !need_conversion ) {
return value;
}
value =
( ( value & 0x000000FF ) << 24 ) |
( ( value & 0x0000FF00 ) << 8 ) |
( ( value & 0x00FF0000 ) >> 8 ) |
( ( value & 0xFF000000 ) >> 24 );
( ( value & 0x000000FF ) << 24 ) | ( ( value & 0x0000FF00 ) << 8 ) |
( ( value & 0x00FF0000 ) >> 8 ) | ( ( value & 0xFF000000 ) >> 24 );
return value;
}
//------------------------------------------------------------------------------
int32_t
operator()( int32_t value ) const
//------------------------------------------------------------------------------
int32_t operator()( int32_t value ) const
{
if ( !need_conversion ) {
return value;
}
return (int32_t)(*this)( (uint32_t)value );
return ( int32_t )( *this )( (uint32_t)value );
}
//------------------------------------------------------------------------------
uint16_t
operator()( uint16_t value ) const
//------------------------------------------------------------------------------
uint16_t operator()( uint16_t value ) const
{
if ( !need_conversion ) {
return value;
}
value =
( ( value & 0x00FF ) << 8 ) |
( ( value & 0xFF00 ) >> 8 );
value = ( ( value & 0x00FF ) << 8 ) | ( ( value & 0xFF00 ) >> 8 );
return value;
}
//------------------------------------------------------------------------------
int16_t
operator()( int16_t value ) const
//------------------------------------------------------------------------------
int16_t operator()( int16_t value ) const
{
if ( !need_conversion ) {
return value;
}
return (int16_t)(*this)( (uint16_t)value );
return ( int16_t )( *this )( (uint16_t)value );
}
//------------------------------------------------------------------------------
int8_t
operator()( int8_t value ) const
{
return value;
}
//------------------------------------------------------------------------------
int8_t operator()( int8_t value ) const { return value; }
//------------------------------------------------------------------------------
uint8_t
operator()( uint8_t value ) const
{
return value;
}
//------------------------------------------------------------------------------
uint8_t operator()( uint8_t value ) const { return value; }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
//------------------------------------------------------------------------------
unsigned char
get_host_encoding() const
//------------------------------------------------------------------------------
unsigned char get_host_encoding() const
{
static const int tmp = 1;
if ( 1 == *(const char*)&tmp ) {
@ -182,20 +152,17 @@ class endianess_convertor {
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
private:
bool need_conversion;
};
//------------------------------------------------------------------------------
inline
uint32_t
elf_hash( const unsigned char *name )
inline uint32_t elf_hash( const unsigned char* name )
{
uint32_t h = 0, g;
while ( *name ) {
h = (h << 4) + *name++;
h = ( h << 4 ) + *name++;
g = h & 0xf0000000;
if ( g != 0 )
h ^= g >> 24;

58
examples/anonymizer/anonymizer.cpp
View File

@ -49,36 +49,36 @@ diff before.txt after.txt
using namespace ELFIO;
void overwrite_data(const std::string &filename, long offset, std::string &str)
void overwrite_data( const std::string& filename,
long offset,
std::string& str )
{
std::ofstream file(filename, std::ios::in | std::ios::out | std::ios::binary);
if (!file)
std::ofstream file( filename,
std::ios::in | std::ios::out | std::ios::binary );
if ( !file )
throw "Error opening file" + filename;
std::string data(str.length(), '-');
file.seekp(offset);
file.write(data.c_str(), data.length() + 1);
std::string data( str.length(), '-' );
file.seekp( offset );
file.write( data.c_str(), data.length() + 1 );
}
void process_string_table(const section *s, const std::string &filename)
void process_string_table( const section* s, const std::string& filename )
{
std::cout << "Info: processing string table section" << std::endl;
int index = 1;
while (index < s->get_size())
{
auto str = std::string(s->get_data() + index);
while ( index < s->get_size() ) {
auto str = std::string( s->get_data() + index );
// For the example purpose, we rename main function name only
if (str == "main")
overwrite_data(filename, s->get_offset() + index, str);
if ( str == "main" )
overwrite_data( filename, s->get_offset() + index, str );
index += str.length() + 1;
}
}
int main(int argc, char **argv)
int main( int argc, char** argv )
{
try
{
if (argc != 2)
{
try {
if ( argc != 2 ) {
std::cout << "Usage: anonymizer <file_name>\n";
return 1;
}
@ -87,28 +87,26 @@ int main(int argc, char **argv)
elfio reader;
if (!reader.load(filename))
{
std::cerr << "File " << filename << " is not found or it is not an ELF file\n";
if ( !reader.load( filename ) ) {
std::cerr << "File " << filename
<< " is not found or it is not an ELF file\n";
return 1;
}
for (auto section = reader.sections.begin(); section != reader.sections.end(); ++section)
{
if ((*section)->get_type() == SHT_STRTAB &&
std::string((*section)->get_name()) == std::string(".strtab"))
{
process_string_table(*section, filename);
for ( auto section = reader.sections.begin();
section != reader.sections.end(); ++section ) {
if ( ( *section )->get_type() == SHT_STRTAB &&
std::string( ( *section )->get_name() ) ==
std::string( ".strtab" ) ) {
process_string_table( *section, filename );
}
}
return 0;
}
catch (const std::string &s)
{
catch ( const std::string& s ) {
std::cerr << s << std::endl;
}
catch (const char *s)
{
catch ( const char* s ) {
std::cerr << s << std::endl;
}
return 1;

16
examples/elfdump/elfdump.cpp
View File

@ -23,8 +23,8 @@ THE SOFTWARE.
*/
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#define ELFIO_NO_INTTYPES
#define _SCL_SECURE_NO_WARNINGS
#define ELFIO_NO_INTTYPES
#endif
#include <iostream>
@ -46,14 +46,14 @@ int main( int argc, char** argv )
return 1;
}
dump::header ( std::cout, reader );
dump::header( std::cout, reader );
dump::section_headers( std::cout, reader );
dump::segment_headers( std::cout, reader );
dump::symbol_tables ( std::cout, reader );
dump::notes ( std::cout, reader );
dump::dynamic_tags ( std::cout, reader );
dump::section_datas ( std::cout, reader );
dump::segment_datas ( std::cout, reader );
dump::symbol_tables( std::cout, reader );
dump::notes( std::cout, reader );
dump::dynamic_tags( std::cout, reader );
dump::section_datas( std::cout, reader );
dump::segment_datas( std::cout, reader );
return 0;
}

22
examples/tutorial/tutorial.cpp
View File

@ -37,11 +37,8 @@ int main( int argc, char** argv )
std::cout << "Number of sections: " << sec_num << std::endl;
for ( int i = 0; i < sec_num; ++i ) {
section* psec = reader.sections[i];
std::cout << " [" << i << "] "
<< psec->get_name()
<< "\t"
<< psec->get_size()
<< std::endl;
std::cout << " [" << i << "] " << psec->get_name() << "\t"
<< psec->get_size() << std::endl;
// Access to section's data
// const char* p = reader.sections[i]->get_data()
}
@ -51,14 +48,9 @@ int main( int argc, char** argv )
std::cout << "Number of segments: " << seg_num << std::endl;
for ( int i = 0; i < seg_num; ++i ) {
const segment* pseg = reader.segments[i];
std::cout << " [" << i << "] 0x" << std::hex
<< pseg->get_flags()
<< "\t0x"
<< pseg->get_virtual_address()
<< "\t0x"
<< pseg->get_file_size()
<< "\t0x"
<< pseg->get_memory_size()
std::cout << " [" << i << "] 0x" << std::hex << pseg->get_flags()
<< "\t0x" << pseg->get_virtual_address() << "\t0x"
<< pseg->get_file_size() << "\t0x" << pseg->get_memory_size()
<< std::endl;
// Access to segments's data
// const char* p = reader.segments[i]->get_data()
@ -79,8 +71,8 @@ int main( int argc, char** argv )
unsigned char other;
// Read symbol properties
symbols.get_symbol( j, name, value, size, bind,
type, section_index, other );
symbols.get_symbol( j, name, value, size, bind, type,
section_index, other );
std::cout << j << " " << name << " " << value << std::endl;
}
}

35
examples/write_obj/write_obj.cpp
View File

@ -25,10 +25,11 @@ int main( void )
writer.set_os_abi( ELFOSABI_LINUX );
writer.set_type( ET_REL );
writer.set_machine(EM_X86_64);
writer.set_machine( EM_X86_64 );
// This is our code
char text[] = { '\xB8', '\x04', '\x00', '\x00', '\x00', // mov eax, 4
char text[] = {
'\xB8', '\x04', '\x00', '\x00', '\x00', // mov eax, 4
'\xBB', '\x01', '\x00', '\x00', '\x00', // mov ebx, 1
'\xB9', '\x00', '\x00', '\x00', '\x00', // mov ecx, msg
'\xBA', '\x0E', '\x00', '\x00', '\x00', // mov edx, 14
@ -37,20 +38,19 @@ int main( void )
'\xCD', '\x80', // int 0x80
'\x48', '\x65', '\x6C', '\x6C', '\x6F', // msg: db 'Hello, World!', 10
'\x2C', '\x20', '\x57', '\x6F', '\x72',
'\x6C', '\x64', '\x21', '\x0A'
};
'\x6C', '\x64', '\x21', '\x0A' };
Elf64_Addr place_to_adjust = 11;
// Create code section
section* text_sec = writer.sections.add( ".text" );
text_sec->set_type ( SHT_PROGBITS );
text_sec->set_flags ( SHF_ALLOC | SHF_EXECINSTR );
text_sec->set_type( SHT_PROGBITS );
text_sec->set_flags( SHF_ALLOC | SHF_EXECINSTR );
text_sec->set_addr_align( 0x10 );
text_sec->set_data ( text, sizeof( text ) );
text_sec->set_data( text, sizeof( text ) );
// Create string table section
section* str_sec = writer.sections.add( ".strtab" );
str_sec->set_type ( SHT_STRTAB );
str_sec->set_type( SHT_STRTAB );
// Create string table writer
string_section_accessor stra( str_sec );
@ -59,29 +59,28 @@ int main( void )
// Create symbol table section
section* sym_sec = writer.sections.add( ".symtab" );
sym_sec->set_type ( SHT_SYMTAB );
sym_sec->set_info ( 1 );
sym_sec->set_type( SHT_SYMTAB );
sym_sec->set_info( 1 );
sym_sec->set_addr_align( 0x4 );
sym_sec->set_entry_size( writer.get_default_entry_size( SHT_SYMTAB ) );
sym_sec->set_link ( str_sec->get_index() );
sym_sec->set_link( str_sec->get_index() );
// Create symbol table writer
symbol_section_accessor syma( writer, sym_sec );
// Add symbol entry (msg has offset == 29)
Elf_Word sym_to_adjust = syma.add_symbol( str_index, 29, 0, STB_GLOBAL,
STT_OBJECT, 0,
text_sec->get_index() );
Elf_Word sym_to_adjust = syma.add_symbol(
str_index, 29, 0, STB_GLOBAL, STT_OBJECT, 0, text_sec->get_index() );
// Another way to add symbol
syma.add_symbol( stra, "_start", 0x00000000, 0, STB_WEAK, STT_FUNC, 0,
text_sec->get_index() );
// Create relocation table section
section* rel_sec = writer.sections.add( ".rel.text" );
rel_sec->set_type ( SHT_REL );
rel_sec->set_info ( text_sec->get_index() );
rel_sec->set_type( SHT_REL );
rel_sec->set_info( text_sec->get_index() );
rel_sec->set_addr_align( 0x4 );
rel_sec->set_entry_size( writer.get_default_entry_size( SHT_REL ) );
rel_sec->set_link ( sym_sec->get_index() );
rel_sec->set_link( sym_sec->get_index() );
// Create relocation table writer
relocation_section_accessor rela( writer, rel_sec );
@ -102,7 +101,7 @@ int main( void )
note_section_accessor note_writer( writer, note_sec );
note_writer.add_note( 0x01, "Created by ELFIO", 0, 0 );
char descr[6] = {0x31, 0x32, 0x33, 0x34, 0x35, 0x36};
char descr[6] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36 };
note_writer.add_note( 0x01, "Never easier!", descr, sizeof( descr ) );
// Create ELF object file

19
examples/writer/writer.cpp
View File

@ -20,7 +20,8 @@ int main( void )
text_sec->set_addr_align( 0x10 );
// Add data into it
char text[] = { '\xB8', '\x04', '\x00', '\x00', '\x00', // mov eax, 4
char text[] = {
'\xB8', '\x04', '\x00', '\x00', '\x00', // mov eax, 4
'\xBB', '\x01', '\x00', '\x00', '\x00', // mov ebx, 1
'\xB9', '\x20', '\x80', '\x04', '\x08', // mov ecx, msg
'\xBA', '\x0E', '\x00', '\x00', '\x00', // mov edx, 14
@ -39,7 +40,8 @@ int main( void )
text_seg->set_align( 0x1000 );
// Add code section into program segment
text_seg->add_section_index( text_sec->get_index(), text_sec->get_addr_align() );
text_seg->add_section_index( text_sec->get_index(),
text_sec->get_addr_align() );
// Create data section
section* data_sec = writer.sections.add( ".data" );
@ -47,10 +49,10 @@ int main( void )
data_sec->set_flags( SHF_ALLOC | SHF_WRITE );
data_sec->set_addr_align( 0x4 );
char data[] = { '\x48', '\x65', '\x6C', '\x6C', '\x6F', // msg: db 'Hello, World!', 10
char data[] = {
'\x48', '\x65', '\x6C', '\x6C', '\x6F', // msg: db 'Hello, World!', 10
'\x2C', '\x20', '\x57', '\x6F', '\x72',
'\x6C', '\x64', '\x21', '\x0A'
};
'\x6C', '\x64', '\x21', '\x0A' };
data_sec->set_data( data, sizeof( data ) );
// Create a read/write segment
@ -62,7 +64,8 @@ int main( void )
data_seg->set_align( 0x10 );
// Add code section into program segment
data_seg->add_section_index( data_sec->get_index(), data_sec->get_addr_align() );
data_seg->add_section_index( data_sec->get_index(),
data_sec->get_addr_align() );
// Add optional signature for the file producer
section* note_sec = writer.sections.add( ".note" );
@ -70,14 +73,14 @@ int main( void )
note_sec->set_addr_align( 1 );
note_section_accessor note_writer( writer, note_sec );
note_writer.add_note( 0x01, "Created by ELFIO", 0, 0 );
char descr[6] = {0x31, 0x32, 0x33, 0x34, 0x35, 0x36};
char descr[6] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36 };
note_writer.add_note( 0x01, "Never easier!", descr, sizeof( descr ) );
// Setup entry point
writer.set_entry( 0x08048000 );
// Create ELF file
writer.save("hello_x86_64");
writer.save( "hello_x86_64" );
return 0;
}

444
tests/ELFIOTest.cpp
View File

@ -10,8 +10,7 @@
using namespace ELFIO;
////////////////////////////////////////////////////////////////////////////////
void
checkHeader( elfio& reader,
void checkHeader( elfio& reader,
unsigned char nClass,
unsigned char encoding,
unsigned char elfVersion,
@ -39,10 +38,8 @@ checkHeader( elfio& reader,
BOOST_CHECK_EQUAL( reader.segments.size(), segNum );
}
////////////////////////////////////////////////////////////////////////////////
void
checkSection( const section* sec,
void checkSection( const section* sec,
Elf_Half index,
std::string name,
Elf_Word type,
@ -66,11 +63,9 @@ checkSection( const section* sec,
BOOST_CHECK_EQUAL( sec->get_entry_size(), entrySize );
}
////////////////////////////////////////////////////////////////////////////////
void
checkSection( const section* sec,
const std::string &name,
void checkSection( const section* sec,
const std::string& name,
Elf_Word type,
Elf_Xword flags,
Elf64_Addr address,
@ -84,10 +79,8 @@ checkSection( const section* sec,
info, addrAlign, entrySize );
}
////////////////////////////////////////////////////////////////////////////////
void
checkSegment( const segment* seg,
void checkSegment( const segment* seg,
Elf_Word type,
Elf64_Addr vaddr,
Elf64_Addr paddr,
@ -105,14 +98,16 @@ checkSegment( const segment* seg,
BOOST_CHECK_EQUAL( seg->get_align(), align );
}
////////////////////////////////////////////////////////////////////////////////
void
checkSymbol( const symbol_section_accessor& sr, Elf_Xword index,
std::string name_, Elf64_Addr value_,
void checkSymbol( const symbol_section_accessor& sr,
Elf_Xword index,
std::string name_,
Elf64_Addr value_,
Elf_Xword size_,
unsigned char bind_, unsigned char type_,
Elf_Half section_, unsigned char other_ )
unsigned char bind_,
unsigned char type_,
Elf_Half section_,
unsigned char other_ )
{
std::string name;
Elf64_Addr value;
@ -122,7 +117,8 @@ checkSymbol( const symbol_section_accessor& sr, Elf_Xword index,
Elf_Half section;
unsigned char other;
BOOST_REQUIRE_EQUAL( sr.get_symbol( index, name, value, size, bind, type, section, other ),
BOOST_REQUIRE_EQUAL(
sr.get_symbol( index, name, value, size, bind, type, section, other ),
true );
BOOST_CHECK_EQUAL( name, name_ );
BOOST_CHECK_EQUAL( value, value_ );
@ -133,13 +129,14 @@ checkSymbol( const symbol_section_accessor& sr, Elf_Xword index,
BOOST_CHECK_EQUAL( other, other_ );
}
////////////////////////////////////////////////////////////////////////////////
void
checkRelocation( const relocation_section_accessor* pRT, Elf_Xword index,
Elf64_Addr offset_, Elf64_Addr symbolValue_,
void checkRelocation( const relocation_section_accessor* pRT,
Elf_Xword index,
Elf64_Addr offset_,
Elf64_Addr symbolValue_,
std::string symbolName_,
unsigned char type_, Elf_Sxword addend_,
unsigned char type_,
Elf_Sxword addend_,
Elf_Sxword calcValue_ )
{
Elf64_Addr offset;
@ -160,11 +157,11 @@ checkRelocation( const relocation_section_accessor* pRT, Elf_Xword index,
BOOST_CHECK_EQUAL( calcValue, calcValue_ );
}
////////////////////////////////////////////////////////////////////////////////
void
checkNote( const note_section_accessor& notes, Elf_Word index,
Elf_Word type_, std::string name_,
void checkNote( const note_section_accessor& notes,
Elf_Word index,
Elf_Word type_,
std::string name_,
Elf_Word descSize_ )
{
Elf_Word type;
@ -179,14 +176,13 @@ void
BOOST_CHECK_EQUAL( descSize, descSize_ );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( load32 )
{
elfio reader;
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/hello_32" ), true );
checkHeader( reader, ELFCLASS32, ELFDATA2LSB, EV_CURRENT, ET_EXEC,
EM_386, 1, 0x80482b0, 0, 28, 7, 0, 0 );
checkHeader( reader, ELFCLASS32, ELFDATA2LSB, EV_CURRENT, ET_EXEC, EM_386,
1, 0x80482b0, 0, 28, 7, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check sections
@ -194,42 +190,39 @@ BOOST_AUTO_TEST_CASE( load32 )
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec = reader.sections[1];
checkSection( sec, 1, ".interp", SHT_PROGBITS, SHF_ALLOC,
0x08048114, 0x13, 0, 0, 1, 0 );
checkSection( sec, 1, ".interp", SHT_PROGBITS, SHF_ALLOC, 0x08048114, 0x13,
0, 0, 1, 0 );
sec = reader.sections[9];
checkSection( sec, 9, ".rel.plt", SHT_REL, SHF_ALLOC,
0x08048234, 0x18, 4, 11, 4, 8 );
checkSection( sec, 9, ".rel.plt", SHT_REL, SHF_ALLOC, 0x08048234, 0x18, 4,
11, 4, 8 );
sec = reader.sections[19];
checkSection( sec, 19, ".dynamic", SHT_DYNAMIC, SHF_WRITE | SHF_ALLOC,
0x080494a0, 0xc8, 5, 0, 4, 8 );
sec = reader.sections[27];
checkSection( sec, 27, ".strtab", SHT_STRTAB, 0,
0x0, 0x259, 0, 0, 1, 0 );
checkSection( sec, 27, ".strtab", SHT_STRTAB, 0, 0x0, 0x259, 0, 0, 1, 0 );
const section* sec1 = reader.sections[ ".strtab" ];
const section* sec1 = reader.sections[".strtab"];
BOOST_CHECK_EQUAL( sec->get_index(), sec1->get_index() );
////////////////////////////////////////////////////////////////////////////
// Check segments
segment* seg = reader.segments[0];
checkSegment( seg, PT_PHDR, 0x08048034, 0x08048034,
0x000e0, 0x000e0, PF_R + PF_X, 4 );
checkSegment( seg, PT_PHDR, 0x08048034, 0x08048034, 0x000e0, 0x000e0,
PF_R + PF_X, 4 );
seg = reader.segments[4];
checkSegment( seg, PT_DYNAMIC, 0x080494a0, 0x080494a0,
0x000c8, 0x000c8, PF_R + PF_W, 4 );
checkSegment( seg, PT_DYNAMIC, 0x080494a0, 0x080494a0, 0x000c8, 0x000c8,
PF_R + PF_W, 4 );
seg = reader.segments[6];
checkSegment( seg, 0x6474E551, 0x0, 0x0,
0x0, 0x0, PF_R + PF_W, 4 );
checkSegment( seg, 0x6474E551, 0x0, 0x0, 0x0, 0x0, PF_R + PF_W, 4 );
////////////////////////////////////////////////////////////////////////////
// Check symbol table
sec = reader.sections[ ".symtab" ];
sec = reader.sections[".symtab"];
symbol_section_accessor sr( reader, sec );
@ -240,8 +233,8 @@ BOOST_AUTO_TEST_CASE( load32 )
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 39, "hello.c", 0x00000000, 0, STB_LOCAL, STT_FILE, SHN_ABS,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 65, "__i686.get_pc_thunk.bx", 0x08048429, 0, STB_GLOBAL, STT_FUNC, 12,
ELF_ST_VISIBILITY( STV_HIDDEN ) );
checkSymbol( sr, 65, "__i686.get_pc_thunk.bx", 0x08048429, 0, STB_GLOBAL,
STT_FUNC, 12, ELF_ST_VISIBILITY( STV_HIDDEN ) );
checkSymbol( sr, 66, "main", 0x08048384, 43, STB_GLOBAL, STT_FUNC, 12,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 67, "_init", 0x0804824c, 0, STB_GLOBAL, STT_FUNC, 10,
@ -249,28 +242,29 @@ BOOST_AUTO_TEST_CASE( load32 )
////////////////////////////////////////////////////////////////////////////
// Check relocation table
sec = reader.sections[ ".rel.dyn" ];
sec = reader.sections[".rel.dyn"];
relocation_section_accessor reloc( reader, sec );
BOOST_CHECK_EQUAL( reloc.get_entries_num(), 1 );
checkRelocation( &reloc, 0, 0x08049568, 0x0, "__gmon_start__", R_386_GLOB_DAT, 0, 0 );
sec = reader.sections[ ".rel.plt" ];
checkRelocation( &reloc, 0, 0x08049568, 0x0, "__gmon_start__",
R_386_GLOB_DAT, 0, 0 );
sec = reader.sections[".rel.plt"];
relocation_section_accessor reloc1( reader, sec );
BOOST_CHECK_EQUAL( reloc1.get_entries_num(), 3 );
checkRelocation( &reloc1, 0, 0x08049578, 0x0, "__gmon_start__", R_X86_64_JUMP_SLOT, 0, 0 );
checkRelocation( &reloc1, 1, 0x0804957c, 0x0, "__libc_start_main", R_X86_64_JUMP_SLOT, 0, 0 );
checkRelocation( &reloc1, 2, 0x08049580, 0x0, "puts", R_X86_64_JUMP_SLOT, 0, 0 );
checkRelocation( &reloc1, 0, 0x08049578, 0x0, "__gmon_start__",
R_X86_64_JUMP_SLOT, 0, 0 );
checkRelocation( &reloc1, 1, 0x0804957c, 0x0, "__libc_start_main",
R_X86_64_JUMP_SLOT, 0, 0 );
checkRelocation( &reloc1, 2, 0x08049580, 0x0, "puts", R_X86_64_JUMP_SLOT, 0,
0 );
////////////////////////////////////////////////////////////////////////////
// Check note reader
sec = reader.sections[ ".note.ABI-tag" ];
sec = reader.sections[".note.ABI-tag"];
note_section_accessor notes( reader, sec );
BOOST_CHECK_EQUAL( notes.get_notes_num(), 1u );
@ -278,7 +272,6 @@ BOOST_AUTO_TEST_CASE( load32 )
checkNote( notes, 0, 1, std::string( "GNU" ), 16 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( load64 )
{
@ -293,31 +286,30 @@ BOOST_AUTO_TEST_CASE( load64 )
////////////////////////////////////////////////////////////////////////////
// Check sections
section* sec = reader.sections[ 0 ];
section* sec = reader.sections[0];
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec =reader.sections[ 1 ];
sec = reader.sections[1];
checkSection( sec, 1, ".interp", SHT_PROGBITS, SHF_ALLOC,
0x0000000000400200, 0x1c, 0, 0, 1, 0 );
sec =reader.sections[ 9 ];
sec = reader.sections[9];
checkSection( sec, 9, ".rela.plt", SHT_RELA, SHF_ALLOC,
0x0000000000400340, 0x30, 4, 11, 8, 0x18 );
checkSection( sec, 9, ".rela.plt", SHT_RELA, SHF_ALLOC, 0x0000000000400340,
0x30, 4, 11, 8, 0x18 );
sec =reader.sections[ 20 ];
sec = reader.sections[20];
checkSection( sec, 20, ".dynamic", SHT_DYNAMIC, SHF_WRITE | SHF_ALLOC,
0x0000000000600698, 0x190, 5, 0, 8, 0x10 );
sec =reader.sections[ 28 ];
sec = reader.sections[28];
checkSection( sec, 28, ".strtab", SHT_STRTAB, 0,
0x0, 0x23f, 0, 0, 1, 0 );
checkSection( sec, 28, ".strtab", SHT_STRTAB, 0, 0x0, 0x23f, 0, 0, 1, 0 );
const section* sec1 = reader.sections[ ".strtab" ];
const section* sec1 = reader.sections[".strtab"];
BOOST_CHECK_EQUAL( sec->get_index(), sec1->get_index() );
////////////////////////////////////////////////////////////////////////////
@ -328,16 +320,15 @@ BOOST_AUTO_TEST_CASE( load64 )
seg = reader.segments[2];
checkSegment( seg, PT_LOAD, 0x0000000000400000, 0x0000000000400000,
0x000000000000066c, 0x000000000000066c, PF_R + PF_X, 0x200000 );
0x000000000000066c, 0x000000000000066c, PF_R + PF_X,
0x200000 );
seg = reader.segments[7];
checkSegment( seg, 0x6474E551, 0x0, 0x0,
0x0, 0x0, PF_R + PF_W, 8 );
checkSegment( seg, 0x6474E551, 0x0, 0x0, 0x0, 0x0, PF_R + PF_W, 8 );
////////////////////////////////////////////////////////////////////////////
// Check symbol table
sec =reader.sections[ ".symtab" ];
sec = reader.sections[".symtab"];
symbol_section_accessor sr( reader, sec );
@ -348,10 +339,10 @@ BOOST_AUTO_TEST_CASE( load64 )
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 40, "hello.c", 0x00000000, 0, STB_LOCAL, STT_FILE, SHN_ABS,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 52, "__gmon_start__", 0x00000000, 0, STB_WEAK, STT_NOTYPE, STN_UNDEF,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 64, "_edata", 0x0060085c, 0, STB_GLOBAL, STT_NOTYPE, SHN_ABS,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 52, "__gmon_start__", 0x00000000, 0, STB_WEAK, STT_NOTYPE,
STN_UNDEF, ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 64, "_edata", 0x0060085c, 0, STB_GLOBAL, STT_NOTYPE,
SHN_ABS, ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 65, "main", 0x00400498, 21, STB_GLOBAL, STT_FUNC, 12,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 66, "_init", 0x00400370, 0, STB_GLOBAL, STT_FUNC, 10,
@ -359,27 +350,27 @@ BOOST_AUTO_TEST_CASE( load64 )
////////////////////////////////////////////////////////////////////////////
// Check relocation table
sec =reader.sections[ ".rela.dyn" ];
sec = reader.sections[".rela.dyn"];
relocation_section_accessor reloc( reader, sec );
BOOST_CHECK_EQUAL( reloc.get_entries_num(), 1 );
checkRelocation( &reloc, 0, 0x00600828, 0x0, "__gmon_start__", R_X86_64_GLOB_DAT, 0, 0 );
sec =reader.sections[ ".rela.plt" ];
checkRelocation( &reloc, 0, 0x00600828, 0x0, "__gmon_start__",
R_X86_64_GLOB_DAT, 0, 0 );
sec = reader.sections[".rela.plt"];
relocation_section_accessor reloc1( reader, sec );
BOOST_CHECK_EQUAL( reloc1.get_entries_num(), 2 );
checkRelocation( &reloc1, 0, 0x00600848, 0x0, "puts", R_X86_64_JUMP_SLOT, 0, 0 );
checkRelocation( &reloc1, 1, 0x00600850, 0x0, "__libc_start_main", R_X86_64_JUMP_SLOT, 0, 0 );
checkRelocation( &reloc1, 0, 0x00600848, 0x0, "puts", R_X86_64_JUMP_SLOT, 0,
0 );
checkRelocation( &reloc1, 1, 0x00600850, 0x0, "__libc_start_main",
R_X86_64_JUMP_SLOT, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check note reader
sec =reader.sections[ ".note.ABI-tag" ];
sec = reader.sections[".note.ABI-tag"];
note_section_accessor notes( reader, sec );
BOOST_CHECK_EQUAL( notes.get_notes_num(), 1u );
@ -387,7 +378,6 @@ BOOST_AUTO_TEST_CASE( load64 )
checkNote( notes, 0, 1, std::string( "GNU" ), 16 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( hello_64_o )
{
@ -397,34 +387,32 @@ BOOST_AUTO_TEST_CASE( hello_64_o )
////////////////////////////////////////////////////////////////////////////
// Check ELF header
checkHeader( reader, ELFCLASS64, ELFDATA2LSB, EV_CURRENT, ET_REL,
EM_X86_64, 1, 0, 0, 13, 0, 0, 0 );
checkHeader( reader, ELFCLASS64, ELFDATA2LSB, EV_CURRENT, ET_REL, EM_X86_64,
1, 0, 0, 13, 0, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check sections
section* sec = reader.sections[ 0 ];
section* sec = reader.sections[0];
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec =reader.sections[ 1 ];
sec = reader.sections[1];
checkSection( sec, 1, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR,
0x0, 0x15, 0, 0, 4, 0 );
checkSection( sec, 1, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR, 0x0,
0x15, 0, 0, 4, 0 );
section* sec1 = reader.sections[ ".text" ];
section* sec1 = reader.sections[".text"];
BOOST_CHECK_EQUAL( sec->get_index(), sec1->get_index() );
sec = reader.sections[12];
checkSection( sec, 12, ".strtab", SHT_STRTAB, 0,
0x0, 0x13, 0, 0, 1, 0 );
checkSection( sec, 12, ".strtab", SHT_STRTAB, 0, 0x0, 0x13, 0, 0, 1, 0 );
sec1 = reader.sections[ ".strtab" ];
sec1 = reader.sections[".strtab"];
BOOST_CHECK_EQUAL( sec->get_index(), sec1->get_index() );
////////////////////////////////////////////////////////////////////////////
// Check symbol table
sec =reader.sections[ ".symtab" ];
sec = reader.sections[".symtab"];
symbol_section_accessor sr( reader, sec );
@ -434,17 +422,16 @@ BOOST_AUTO_TEST_CASE( hello_64_o )
////////////////////////////////////////////////////////////////////////////
// Check relocation table
sec =reader.sections[ ".rela.text" ];
sec = reader.sections[".rela.text"];
relocation_section_accessor reloc( reader, sec );
BOOST_CHECK_EQUAL( reloc.get_entries_num(), 2 );
checkRelocation( &reloc, 0, 0x00000005, 0x0, "", R_X86_64_32, 0, 0 );
checkRelocation( &reloc, 1, 0x0000000A, 0x0, "puts", R_X86_64_PC32, 0xfffffffffffffffcULL, -14 );
sec =reader.sections[ ".rela.eh_frame" ];
checkRelocation( &reloc, 1, 0x0000000A, 0x0, "puts", R_X86_64_PC32,
0xfffffffffffffffcULL, -14 );
sec = reader.sections[".rela.eh_frame"];
relocation_section_accessor reloc1( reader, sec );
BOOST_CHECK_EQUAL( reloc1.get_entries_num(), 1 );
@ -452,7 +439,6 @@ BOOST_AUTO_TEST_CASE( hello_64_o )
checkRelocation( &reloc1, 0, 0x00000020, 0x0, "", R_X86_64_32, 0, 0 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( hello_32_o )
{
@ -462,36 +448,33 @@ BOOST_AUTO_TEST_CASE( hello_32_o )
////////////////////////////////////////////////////////////////////////////
// Check ELF header
checkHeader( reader, ELFCLASS32, ELFDATA2LSB, EV_CURRENT, ET_REL,
EM_386, 1, 0, 0, 11, 0, 0, 0 );
checkHeader( reader, ELFCLASS32, ELFDATA2LSB, EV_CURRENT, ET_REL, EM_386, 1,
0, 0, 11, 0, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check sections
section* sec = reader.sections[ 0 ];
section* sec = reader.sections[0];
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec =reader.sections[ 1 ];
sec = reader.sections[1];
checkSection( sec, 1, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR,
0x0, 0x2b, 0, 0, 4, 0 );
checkSection( sec, 1, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR, 0x0,
0x2b, 0, 0, 4, 0 );
section* sec1 = reader.sections[ ".text" ];
section* sec1 = reader.sections[".text"];
BOOST_CHECK_EQUAL( sec->get_index(), sec1->get_index() );
sec = reader.sections[10];
sec = reader.sections[ 10 ];
checkSection( sec, 10, ".strtab", SHT_STRTAB, 0, 0x0, 0x13, 0, 0, 1, 0 );
checkSection( sec, 10, ".strtab", SHT_STRTAB, 0,
0x0, 0x13, 0, 0, 1, 0 );
sec1 = reader.sections[ ".strtab" ];
sec1 = reader.sections[".strtab"];
BOOST_CHECK_EQUAL( sec->get_index(), sec1->get_index() );
////////////////////////////////////////////////////////////////////////////
// Check symbol table
sec =reader.sections[ ".symtab" ];
sec = reader.sections[".symtab"];
symbol_section_accessor sr( reader, sec );
@ -501,8 +484,7 @@ BOOST_AUTO_TEST_CASE( hello_32_o )
////////////////////////////////////////////////////////////////////////////
// Check relocation table
sec =reader.sections[ ".rel.text" ];
sec = reader.sections[".rel.text"];
relocation_section_accessor reloc( reader, sec );
BOOST_CHECK_EQUAL( reloc.get_entries_num(), 2 );
@ -511,7 +493,6 @@ BOOST_AUTO_TEST_CASE( hello_32_o )
checkRelocation( &reloc, 1, 0x00000019, 0x0, "puts", R_386_PC32, 0x0, -25 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( test_ppc_o )
{
@ -521,48 +502,45 @@ BOOST_AUTO_TEST_CASE( test_ppc_o )
////////////////////////////////////////////////////////////////////////////
// Check ELF header
checkHeader( reader, ELFCLASS32, ELFDATA2MSB, EV_CURRENT, ET_REL,
EM_PPC, 1, 0, 0, 16, 0, 0, 0 );
checkHeader( reader, ELFCLASS32, ELFDATA2MSB, EV_CURRENT, ET_REL, EM_PPC, 1,
0, 0, 16, 0, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check sections
section* sec = reader.sections[ 0 ];
section* sec = reader.sections[0];
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec =reader.sections[ 1 ];
sec = reader.sections[1];
checkSection( sec, 1, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR,
0x0, 0x118, 0, 0, 4, 0 );
checkSection( sec, 1, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR, 0x0,
0x118, 0, 0, 4, 0 );
section* sec1 = reader.sections[ ".text" ];
section* sec1 = reader.sections[".text"];
BOOST_CHECK_EQUAL( sec->get_index(), sec1->get_index() );
sec =reader.sections[ 15 ];
sec = reader.sections[15];
checkSection( sec, 15, ".strtab", SHT_STRTAB, 0,
0x0, 0x14f, 0, 0, 1, 0 );
checkSection( sec, 15, ".strtab", SHT_STRTAB, 0, 0x0, 0x14f, 0, 0, 1, 0 );
sec1 = reader.sections[ ".strtab" ];
sec1 = reader.sections[".strtab"];
BOOST_CHECK_EQUAL( sec->get_index(), sec1->get_index() );
////////////////////////////////////////////////////////////////////////////
// Check symbol table
sec =reader.sections[ ".symtab" ];
sec = reader.sections[".symtab"];
symbol_section_accessor sr( reader, sec );
BOOST_CHECK_EQUAL( sr.get_symbols_num(), 24 );
checkSymbol( sr, 14, "main", 0x00000000, 92, STB_GLOBAL, STT_FUNC, 1,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 8, "_GLOBAL__I_main", 0x000000DC, 60, STB_LOCAL, STT_FUNC, 1,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 8, "_GLOBAL__I_main", 0x000000DC, 60, STB_LOCAL, STT_FUNC,
1, ELF_ST_VISIBILITY( STV_DEFAULT ) );
////////////////////////////////////////////////////////////////////////////
// Check relocation table
sec =reader.sections[ ".rela.text" ];
sec = reader.sections[".rela.text"];
relocation_section_accessor reloc( reader, sec );
BOOST_CHECK_EQUAL( reloc.get_entries_num(), 18 );
@ -571,16 +549,14 @@ BOOST_AUTO_TEST_CASE( test_ppc_o )
checkRelocation( &reloc, 1, 0x0000001a, 0x0, "_ZSt4cout", 4, 0x0, 0 );
checkRelocation( &reloc, 17, 0x000000c0, 0x0, "__cxa_atexit", 10, 0x0, 0 );
sec =reader.sections[ ".rela.ctors" ];
sec = reader.sections[".rela.ctors"];
relocation_section_accessor reloc1( reader, sec );
BOOST_CHECK_EQUAL( reloc1.get_entries_num(), 1 );
checkRelocation( &reloc1, 0, 0x00000000, 0x0, "", 1, 0xDC, 0xDC );
sec =reader.sections[ ".rela.eh_frame" ];
sec = reader.sections[".rela.eh_frame"];
relocation_section_accessor reloc2( reader, sec );
BOOST_CHECK_EQUAL( reloc2.get_entries_num(), 3 );
@ -588,7 +564,6 @@ BOOST_AUTO_TEST_CASE( test_ppc_o )
checkRelocation( &reloc2, 1, 0x00000020, 0x0, "", 1, 0x0, 0x0 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( test_ppc )
{
@ -598,57 +573,53 @@ BOOST_AUTO_TEST_CASE( test_ppc )
////////////////////////////////////////////////////////////////////////////
// Check ELF header
checkHeader( reader, ELFCLASS32, ELFDATA2MSB, EV_CURRENT, ET_EXEC,
EM_PPC, 1, 0x10000550, 0, 31, 8, 0, 0 );
checkHeader( reader, ELFCLASS32, ELFDATA2MSB, EV_CURRENT, ET_EXEC, EM_PPC,
1, 0x10000550, 0, 31, 8, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check sections
section* sec = reader.sections[ 0 ];
section* sec = reader.sections[0];
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec =reader.sections[ 1 ];
sec = reader.sections[1];
checkSection( sec, 1, ".interp", SHT_PROGBITS, SHF_ALLOC,
0x0000000010000134, 0xd, 0, 0, 1, 0 );
sec =reader.sections[ 9 ];
sec = reader.sections[9];
checkSection( sec, 9, ".rela.plt", SHT_RELA, SHF_ALLOC,
0x00000000010000494, 0x6c, 4, 22, 4, 0xc );
checkSection( sec, 9, ".rela.plt", SHT_RELA, SHF_ALLOC, 0x00000000010000494,
0x6c, 4, 22, 4, 0xc );
sec =reader.sections[ 20 ];
sec = reader.sections[20];
checkSection( sec, 20, ".dynamic", SHT_DYNAMIC, SHF_WRITE | SHF_ALLOC,
0x0000000010010aec, 0xe8, 5, 0, 4, 0x8 );
sec =reader.sections[ 28 ];
sec = reader.sections[28];
checkSection( sec, 28, ".shstrtab", SHT_STRTAB, 0,
0x0, 0x101, 0, 0, 1, 0 );
checkSection( sec, 28, ".shstrtab", SHT_STRTAB, 0, 0x0, 0x101, 0, 0, 1, 0 );
const section* sec1 = reader.sections[ ".shstrtab" ];
const section* sec1 = reader.sections[".shstrtab"];
BOOST_CHECK_EQUAL( sec->get_index(), sec1->get_index() );
////////////////////////////////////////////////////////////////////////////
// Check segments
segment* seg = reader.segments[0];
checkSegment( seg, PT_PHDR, 0x10000034, 0x10000034,
0x00100, 0x00100, PF_R + PF_X, 4 );
checkSegment( seg, PT_PHDR, 0x10000034, 0x10000034, 0x00100, 0x00100,
PF_R + PF_X, 4 );
seg = reader.segments[2];
checkSegment( seg, PT_LOAD, 0x10000000, 0x10000000,
0x00acc, 0x00acc, PF_R + PF_X, 0x10000 );
checkSegment( seg, PT_LOAD, 0x10000000, 0x10000000, 0x00acc, 0x00acc,
PF_R + PF_X, 0x10000 );
seg = reader.segments[7];
checkSegment( seg, 0x6474E551, 0x0, 0x0,
0x0, 0x0, PF_R + PF_W, 0x4 );
checkSegment( seg, 0x6474E551, 0x0, 0x0, 0x0, 0x0, PF_R + PF_W, 0x4 );
////////////////////////////////////////////////////////////////////////////
// Check symbol table
sec =reader.sections[ ".symtab" ];
sec = reader.sections[".symtab"];
symbol_section_accessor sr( reader, sec );
@ -657,11 +628,12 @@ BOOST_AUTO_TEST_CASE( test_ppc )
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 1, "", 0x10000134, 0, STB_LOCAL, STT_SECTION, 1,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 40, "__CTOR_END__", 0x10010AD4, 0, STB_LOCAL, STT_OBJECT, 16,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 52, "__init_array_start", 0x10010acc, 0, STB_LOCAL, STT_NOTYPE, 16,
ELF_ST_VISIBILITY( STV_HIDDEN ) );
checkSymbol( sr, 64, "_ZNSt8ios_base4InitD1Ev@@GLIBCXX_3.4", 0x10000920, 204, STB_GLOBAL, STT_FUNC, SHN_UNDEF,
checkSymbol( sr, 40, "__CTOR_END__", 0x10010AD4, 0, STB_LOCAL, STT_OBJECT,
16, ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 52, "__init_array_start", 0x10010acc, 0, STB_LOCAL,
STT_NOTYPE, 16, ELF_ST_VISIBILITY( STV_HIDDEN ) );
checkSymbol( sr, 64, "_ZNSt8ios_base4InitD1Ev@@GLIBCXX_3.4", 0x10000920,
204, STB_GLOBAL, STT_FUNC, SHN_UNDEF,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
checkSymbol( sr, 78, "main", 0x1000069c, 92, STB_GLOBAL, STT_FUNC, 11,
ELF_ST_VISIBILITY( STV_DEFAULT ) );
@ -670,27 +642,25 @@ BOOST_AUTO_TEST_CASE( test_ppc )
////////////////////////////////////////////////////////////////////////////
// Check relocation table
sec =reader.sections[ ".rela.dyn" ];
sec = reader.sections[".rela.dyn"];
relocation_section_accessor reloc( reader, sec );
BOOST_CHECK_EQUAL( reloc.get_entries_num(), 2 );
checkRelocation( &reloc, 1, 0x10010c0c, 0x10010c0c, "_ZSt4cout", 19, 0, 0 );
sec =reader.sections[ ".rela.plt" ];
sec = reader.sections[".rela.plt"];
relocation_section_accessor reloc1( reader, sec );
BOOST_CHECK_EQUAL( reloc1.get_entries_num(), 9 );
checkRelocation( &reloc1, 0, 0x10010be4, 0x100008e0, "__cxa_atexit", 21, 0, 0 );
checkRelocation( &reloc1, 0, 0x10010be4, 0x100008e0, "__cxa_atexit", 21, 0,
0 );
checkRelocation( &reloc1, 1, 0x10010be8, 0x0, "__gmon_start__", 21, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check note reader
sec =reader.sections[ ".note.ABI-tag" ];
sec = reader.sections[".note.ABI-tag"];
note_section_accessor notes( reader, sec );
BOOST_CHECK_EQUAL( notes.get_notes_num(), 1u );
@ -698,7 +668,6 @@ BOOST_AUTO_TEST_CASE( test_ppc )
checkNote( notes, 0, 1, std::string( "GNU" ), 16 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( test_dummy_out_i386_32 )
{
@ -721,7 +690,7 @@ BOOST_AUTO_TEST_CASE( test_dummy_out_i386_32 )
note_sec->set_flags( SHF_ALLOC );
note_sec->set_addr_align( 4 );
note_section_accessor note_writer( writer, note_sec );
char descr[6] = {0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
char descr[6] = { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
note_writer.add_note( 0x77, "Hello", &descr, 6 );
BOOST_CHECK_EQUAL( note_sec->get_index(), 2 );
@ -729,32 +698,29 @@ BOOST_AUTO_TEST_CASE( test_dummy_out_i386_32 )
writer.save( "elf_examples/elf_dummy_header_i386_32.elf" );
elfio reader;
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/elf_dummy_header_i386_32.elf" ),
true );
BOOST_REQUIRE_EQUAL(
reader.load( "elf_examples/elf_dummy_header_i386_32.elf" ), true );
////////////////////////////////////////////////////////////////////////////
// Check ELF header
checkHeader( reader, ELFCLASS32, ELFDATA2LSB, EV_CURRENT, ET_REL,
EM_386, EV_CURRENT, 0x80482b0, 0, 3, 0, 0, 0 );
checkHeader( reader, ELFCLASS32, ELFDATA2LSB, EV_CURRENT, ET_REL, EM_386,
EV_CURRENT, 0x80482b0, 0, 3, 0, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check sections
section* sec = reader.sections[ "" ];
section* sec = reader.sections[""];
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec = reader.sections[ ".shstrtab" ];
sec = reader.sections[".shstrtab"];
checkSection( sec, 1, ".shstrtab", SHT_STRTAB, 0,
0, 17, 0, 0, 1, 0 );
checkSection( sec, 1, ".shstrtab", SHT_STRTAB, 0, 0, 17, 0, 0, 1, 0 );
sec =reader.sections[ ".note" ];
sec = reader.sections[".note"];
BOOST_CHECK_EQUAL( sec->get_index(), 2 );
checkSection( sec, 2, ".note", SHT_NOTE, SHF_ALLOC,
0, 28, 0, 0, 4, 0 );
checkSection( sec, 2, ".note", SHT_NOTE, SHF_ALLOC, 0, 28, 0, 0, 4, 0 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( test_dummy_out_ppc_32 )
{
@ -777,7 +743,7 @@ BOOST_AUTO_TEST_CASE( test_dummy_out_ppc_32 )
note_sec->set_flags( SHF_ALLOC );
note_sec->set_addr_align( 4 );
note_section_accessor note_writer( writer, note_sec );
char descr[6] = {0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
char descr[6] = { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
note_writer.add_note( 0x77, "Hello", &descr, 6 );
BOOST_CHECK_EQUAL( note_sec->get_index(), 2 );
@ -785,32 +751,29 @@ BOOST_AUTO_TEST_CASE( test_dummy_out_ppc_32 )
writer.save( "elf_examples/elf_dummy_header_ppc_32.elf" );
elfio reader;
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/elf_dummy_header_ppc_32.elf" ),
true );
BOOST_REQUIRE_EQUAL(
reader.load( "elf_examples/elf_dummy_header_ppc_32.elf" ), true );
////////////////////////////////////////////////////////////////////////////
// Check ELF header
checkHeader( reader, ELFCLASS32, ELFDATA2MSB, EV_CURRENT, ET_REL,
EM_PPC, EV_CURRENT, 0x80482b0, 0, 3, 0, 0, 0 );
checkHeader( reader, ELFCLASS32, ELFDATA2MSB, EV_CURRENT, ET_REL, EM_PPC,
EV_CURRENT, 0x80482b0, 0, 3, 0, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check sections
section* sec = reader.sections[ "" ];
section* sec = reader.sections[""];
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec =reader.sections[ ".note" ];
sec = reader.sections[".note"];
BOOST_CHECK_EQUAL( sec->get_index(), 2 );
checkSection( sec, 2, ".note", SHT_NOTE, SHF_ALLOC,
0, 28, 0, 0, 4, 0 );
checkSection( sec, 2, ".note", SHT_NOTE, SHF_ALLOC, 0, 28, 0, 0, 4, 0 );
sec =reader.sections[ ".shstrtab" ];
sec = reader.sections[".shstrtab"];
checkSection( sec, 1, ".shstrtab", SHT_STRTAB, 0,
0, 17, 0, 0, 1, 0 );
checkSection( sec, 1, ".shstrtab", SHT_STRTAB, 0, 0, 17, 0, 0, 1, 0 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( test_dummy_out_i386_64 )
{
@ -833,7 +796,7 @@ BOOST_AUTO_TEST_CASE( test_dummy_out_i386_64 )
note_sec->set_flags( SHF_ALLOC );
note_sec->set_addr_align( 4 );
note_section_accessor note_writer( writer, note_sec );
char descr[6] = {0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
char descr[6] = { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
note_writer.add_note( 0x77, "Hello", &descr, 6 );
BOOST_CHECK_EQUAL( note_sec->get_index(), 2 );
@ -841,32 +804,29 @@ BOOST_AUTO_TEST_CASE( test_dummy_out_i386_64 )
writer.save( "elf_examples/elf_dummy_header_i386_64.elf" );
elfio reader;
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/elf_dummy_header_i386_64.elf" ),
true );
BOOST_REQUIRE_EQUAL(
reader.load( "elf_examples/elf_dummy_header_i386_64.elf" ), true );
////////////////////////////////////////////////////////////////////////////
// Check ELF header
checkHeader( reader, ELFCLASS64, ELFDATA2LSB, EV_CURRENT, ET_REL,
EM_X86_64, EV_CURRENT, 0x120380482b0ull, 0, 3, 0, 0, 0 );
checkHeader( reader, ELFCLASS64, ELFDATA2LSB, EV_CURRENT, ET_REL, EM_X86_64,
EV_CURRENT, 0x120380482b0ull, 0, 3, 0, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check sections
section* sec = reader.sections[ "" ];
section* sec = reader.sections[""];
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec =reader.sections[ ".note" ];
sec = reader.sections[".note"];
BOOST_CHECK_EQUAL( sec->get_index(), 2 );
checkSection( sec, 2, ".note", SHT_NOTE, SHF_ALLOC,
0, 28, 0, 0, 4, 0 );
checkSection( sec, 2, ".note", SHT_NOTE, SHF_ALLOC, 0, 28, 0, 0, 4, 0 );
sec =reader.sections[ ".shstrtab" ];
sec = reader.sections[".shstrtab"];
checkSection( sec, 1, ".shstrtab", SHT_STRTAB, 0,
0, 17, 0, 0, 1, 0 );
checkSection( sec, 1, ".shstrtab", SHT_STRTAB, 0, 0, 17, 0, 0, 1, 0 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( test_dummy_out_ppc_64 )
{
@ -889,7 +849,7 @@ BOOST_AUTO_TEST_CASE( test_dummy_out_ppc_64 )
note_sec->set_flags( SHF_ALLOC );
note_sec->set_addr_align( 4 );
note_section_accessor note_writer( writer, note_sec );
char descr[6] = {0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
char descr[6] = { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
note_writer.add_note( 0x77, "Hello", &descr, 6 );
BOOST_CHECK_EQUAL( note_sec->get_index(), 2 );
@ -897,42 +857,38 @@ BOOST_AUTO_TEST_CASE( test_dummy_out_ppc_64 )
writer.save( "elf_examples/elf_dummy_header_ppc_64.elf" );
elfio reader;
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/elf_dummy_header_ppc_64.elf" ),
true );
BOOST_REQUIRE_EQUAL(
reader.load( "elf_examples/elf_dummy_header_ppc_64.elf" ), true );
////////////////////////////////////////////////////////////////////////////
// Check ELF header
checkHeader( reader, ELFCLASS64, ELFDATA2MSB, EV_CURRENT, ET_REL,
EM_PPC64, EV_CURRENT, 0x120380482b0ull, 0, 3, 0, 0, 0 );
checkHeader( reader, ELFCLASS64, ELFDATA2MSB, EV_CURRENT, ET_REL, EM_PPC64,
EV_CURRENT, 0x120380482b0ull, 0, 3, 0, 0, 0 );
////////////////////////////////////////////////////////////////////////////
// Check sections
section* sec = reader.sections[ "" ];
section* sec = reader.sections[""];
checkSection( sec, 0, "", SHT_NULL, 0, 0, 0, 0, 0, 0, 0 );
sec =reader.sections[ ".shstrtab" ];
sec = reader.sections[".shstrtab"];
checkSection( sec, 1, ".shstrtab", SHT_STRTAB, 0,
0, 17, 0, 0, 1, 0 );
checkSection( sec, 1, ".shstrtab", SHT_STRTAB, 0, 0, 17, 0, 0, 1, 0 );
sec = reader.sections[ ".note" ];
sec = reader.sections[".note"];
BOOST_CHECK_EQUAL( sec->get_index(), 2 );
checkSection( sec, 2, ".note", SHT_NOTE, SHF_ALLOC,
0, 28, 0, 0, 4, 0 );
checkSection( sec, 2, ".note", SHT_NOTE, SHF_ALLOC, 0, 28, 0, 0, 4, 0 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( test_dynamic_64_1 )
{
elfio reader;
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/main" ),
true );
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/main" ), true );
section* dynsec = reader.sections[".dynamic"];
BOOST_REQUIRE( dynsec != NULL);
BOOST_REQUIRE( dynsec != NULL );
dynamic_section_accessor da( reader, dynsec );
@ -958,17 +914,15 @@ BOOST_AUTO_TEST_CASE( test_dynamic_64_1 )
BOOST_CHECK_EQUAL( value, 0 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( test_dynamic_64_2 )
{
elfio reader;
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/libfunc.so" ),
true );
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/libfunc.so" ), true );
section* dynsec = reader.sections[".dynamic"];
BOOST_REQUIRE( dynsec != NULL);
BOOST_REQUIRE( dynsec != NULL );
dynamic_section_accessor da( reader, dynsec );
@ -991,17 +945,15 @@ BOOST_AUTO_TEST_CASE( test_dynamic_64_2 )
BOOST_CHECK_EQUAL( value, 0 );
}
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE( test_dynamic_64_3 )
{
elfio reader;
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/main" ),
true );
BOOST_REQUIRE_EQUAL( reader.load( "elf_examples/main" ), true );
section* dynsec = reader.sections[".dynamic"];
BOOST_REQUIRE( dynsec != NULL);
BOOST_REQUIRE( dynsec != NULL );
dynamic_section_accessor da( reader, dynsec );
BOOST_CHECK_EQUAL( da.get_entries_num(), 26 );
@ -1022,9 +974,7 @@ BOOST_AUTO_TEST_CASE( test_dynamic_64_3 )
for ( unsigned int i = 0; i < da.get_entries_num(); ++i ) {
da.get_entry( i, tag, value, str );
if ( tag == DT_NEEDED ||
tag == DT_SONAME ||
tag == DT_RPATH ||
if ( tag == DT_NEEDED || tag == DT_SONAME || tag == DT_RPATH ||
tag == DT_RUNPATH ) {
da1.add_entry( tag, str );
}
@ -1038,9 +988,7 @@ BOOST_AUTO_TEST_CASE( test_dynamic_64_3 )
da1.get_entry( i, tag1, value1, str1 );
BOOST_CHECK_EQUAL( tag, tag1 );
if ( tag == DT_NEEDED ||
tag == DT_SONAME ||
tag == DT_RPATH ||
if ( tag == DT_NEEDED || tag == DT_SONAME || tag == DT_RPATH ||
tag == DT_RUNPATH ) {
BOOST_CHECK_EQUAL( str, str1 );
}

894
tests/ELFIOTest1.cpp
View File

File diff suppressed because it is too large Load Diff