mirror/ELFIO
1
0
Fork 0
mirror of https://github.com/serge1/ELFIO.git synced 2025-01-13 18:52:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

'noexept' added to upper level API members

Browse Source
This commit is contained in:
Serge Lamikhov-Center 2022-11-12 17:00:08 +02:00
parent ad8b641f96
commit 4320ea915e
6 changed files with 142 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
elfio/elfio.hpp
View File

@ -42,17 +42,17 @@ THE SOFTWARE.
#include <elfio/elfio_strings.hpp> #include <elfio/elfio_strings.hpp>
#define ELFIO_HEADER_ACCESS_GET( TYPE, FNAME ) \ #define ELFIO_HEADER_ACCESS_GET( TYPE, FNAME ) \
TYPE get_##FNAME() const \ TYPE get_##FNAME() const noexcept \
{ \ { \
return header ? ( header->get_##FNAME() ) : 0; \ return header ? ( header->get_##FNAME() ) : 0; \
} }
#define ELFIO_HEADER_ACCESS_GET_SET( TYPE, FNAME ) \ #define ELFIO_HEADER_ACCESS_GET_SET( TYPE, FNAME ) \
TYPE get_##FNAME() const \ TYPE get_##FNAME() const noexcept \
{ \ { \
return header ? ( header->get_##FNAME() ) : 0; \ return header ? ( header->get_##FNAME() ) : 0; \
} \ } \
void set_##FNAME( TYPE val ) \ void set_##FNAME( TYPE val ) noexcept \
{ \ { \
if ( header ) { \ if ( header ) { \
header->set_##FNAME( val ); \ header->set_##FNAME( val ); \
@ -123,7 +123,7 @@ class elfio
// clang-format on // clang-format on
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void create( unsigned char file_class, unsigned char encoding ) void create( unsigned char file_class, unsigned char encoding ) noexcept
{ {
sections_.clear(); sections_.clear();
segments_.clear(); segments_.clear();
@ -132,13 +132,14 @@ class elfio
create_mandatory_sections(); create_mandatory_sections();
} }
void set_address_translation( std::vector<address_translation>& addr_trans ) void set_address_translation(
std::vector<address_translation>& addr_trans ) noexcept
{ {
addr_translator.set_address_translation( addr_trans ); addr_translator.set_address_translation( addr_trans );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool load( const std::string& file_name, bool is_lazy = false ) bool load( const std::string& file_name, bool is_lazy = false ) noexcept
{ {
std::ifstream stream; std::ifstream stream;
stream.open( file_name.c_str(), std::ios::in | std::ios::binary ); stream.open( file_name.c_str(), std::ios::in | std::ios::binary );
@ -150,7 +151,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool load( std::istream& stream, bool is_lazy = false ) bool load( std::istream& stream, bool is_lazy = false ) noexcept
{ {
sections_.clear(); sections_.clear();
segments_.clear(); segments_.clear();
@ -192,7 +193,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool save( const std::string& file_name ) bool save( const std::string& file_name ) noexcept
{ {
std::ofstream stream; std::ofstream stream;
stream.open( file_name.c_str(), std::ios::out | std::ios::binary ); stream.open( file_name.c_str(), std::ios::out | std::ios::binary );
@ -204,7 +205,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool save( std::ostream& stream ) bool save( std::ostream& stream ) noexcept
{ {
if ( !stream || header == nullptr ) { if ( !stream || header == nullptr ) {
return false; return false;
@ -260,10 +261,13 @@ class elfio
ELFIO_HEADER_ACCESS_GET_SET( Elf_Half, section_name_str_index ); 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 noexcept
{
return convertor;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Elf_Xword get_default_entry_size( Elf_Word section_type ) const Elf_Xword get_default_entry_size( Elf_Word section_type ) const noexcept
{ {
switch ( section_type ) { switch ( section_type ) {
case SHT_RELA: case SHT_RELA:
@ -303,7 +307,7 @@ class elfio
//! returns an empty string if no problems are detected, //! returns an empty string if no problems are detected,
//! or a string containing an error message if problems are found, //! or a string containing an error message if problems are found,
//! with one error per line. //! with one error per line.
std::string validate() const std::string validate() const noexcept
{ {
// clang-format off // clang-format off
@ -365,20 +369,23 @@ class elfio
private: private:
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static bool is_offset_in_section( Elf64_Off offset, const section* sec ) static bool is_offset_in_section( Elf64_Off offset,
const section* sec ) noexcept
{ {
return ( offset >= sec->get_offset() ) && return ( offset >= sec->get_offset() ) &&
( offset < ( sec->get_offset() + sec->get_size() ) ); ( offset < ( sec->get_offset() + sec->get_size() ) );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static Elf64_Addr get_virtual_addr( Elf64_Off offset, const section* sec ) static Elf64_Addr get_virtual_addr( Elf64_Off offset,
const section* sec ) noexcept
{ {
return sec->get_address() + offset - sec->get_offset(); return sec->get_address() + offset - sec->get_offset();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
const section* find_prog_section_for_offset( Elf64_Off offset ) const const section*
find_prog_section_for_offset( Elf64_Off offset ) const noexcept
{ {
for ( const auto& sec : sections ) { for ( const auto& sec : sections ) {
if ( sec->get_type() == SHT_PROGBITS && if ( sec->get_type() == SHT_PROGBITS &&
@ -391,18 +398,18 @@ class elfio
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::unique_ptr<elf_header> create_header( unsigned char file_class, std::unique_ptr<elf_header> create_header( unsigned char file_class,
unsigned char encoding ) unsigned char encoding ) noexcept
{ {
std::unique_ptr<elf_header> new_header; std::unique_ptr<elf_header> new_header;
if ( file_class == ELFCLASS64 ) { if ( file_class == ELFCLASS64 ) {
new_header = new_header = std::unique_ptr<elf_header>(
std::unique_ptr<elf_header>( new elf_header_impl<Elf64_Ehdr>( new ( std::nothrow ) elf_header_impl<Elf64_Ehdr>(
&convertor, encoding, &addr_translator ) ); &convertor, encoding, &addr_translator ) );
} }
else if ( file_class == ELFCLASS32 ) { else if ( file_class == ELFCLASS32 ) {
new_header = new_header = std::unique_ptr<elf_header>(
std::unique_ptr<elf_header>( new elf_header_impl<Elf32_Ehdr>( new ( std::nothrow ) elf_header_impl<Elf32_Ehdr>(
&convertor, encoding, &addr_translator ) ); &convertor, encoding, &addr_translator ) );
} }
else { else {
@ -413,17 +420,19 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
section* create_section() section* create_section() noexcept
{ {
unsigned char file_class = get_class(); unsigned char file_class = get_class();
if ( file_class == ELFCLASS64 ) { if ( file_class == ELFCLASS64 ) {
sections_.emplace_back( new section_impl<Elf64_Shdr>( sections_.emplace_back(
&convertor, &addr_translator, compression ) ); new ( std::nothrow ) section_impl<Elf64_Shdr>(
&convertor, &addr_translator, compression ) );
} }
else if ( file_class == ELFCLASS32 ) { else if ( file_class == ELFCLASS32 ) {
sections_.emplace_back( new section_impl<Elf32_Shdr>( sections_.emplace_back(
&convertor, &addr_translator, compression ) ); new ( std::nothrow ) section_impl<Elf32_Shdr>(
&convertor, &addr_translator, compression ) );
} }
else { else {
sections_.pop_back(); sections_.pop_back();
@ -437,17 +446,19 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
segment* create_segment() segment* create_segment() noexcept
{ {
unsigned char file_class = header->get_class(); unsigned char file_class = header->get_class();
if ( file_class == ELFCLASS64 ) { if ( file_class == ELFCLASS64 ) {
segments_.emplace_back( segments_.emplace_back(
new segment_impl<Elf64_Phdr>( &convertor, &addr_translator ) ); new ( std::nothrow )
segment_impl<Elf64_Phdr>( &convertor, &addr_translator ) );
} }
else if ( file_class == ELFCLASS32 ) { else if ( file_class == ELFCLASS32 ) {
segments_.emplace_back( segments_.emplace_back(
new segment_impl<Elf32_Phdr>( &convertor, &addr_translator ) ); new ( std::nothrow )
segment_impl<Elf32_Phdr>( &convertor, &addr_translator ) );
} }
else { else {
segments_.pop_back(); segments_.pop_back();
@ -461,7 +472,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void create_mandatory_sections() void create_mandatory_sections() noexcept
{ {
// Create null section without calling to 'add_section' as no string // Create null section without calling to 'add_section' as no string
// section containing section names exists yet // section containing section names exists yet
@ -477,7 +488,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool load_sections( std::istream& stream ) bool load_sections( std::istream& stream ) noexcept
{ {
unsigned char file_class = header->get_class(); unsigned char file_class = header->get_class();
Elf_Half entry_size = header->get_section_entry_size(); Elf_Half entry_size = header->get_section_entry_size();
@ -524,7 +535,7 @@ class elfio
static bool is_sect_in_seg( Elf64_Off sect_begin, static bool is_sect_in_seg( Elf64_Off sect_begin,
Elf_Xword sect_size, Elf_Xword sect_size,
Elf64_Off seg_begin, Elf64_Off seg_begin,
Elf64_Off seg_end ) Elf64_Off seg_end ) noexcept
{ {
return ( seg_begin <= sect_begin ) && return ( seg_begin <= sect_begin ) &&
( sect_begin + sect_size <= seg_end ) && ( sect_begin + sect_size <= seg_end ) &&
@ -535,7 +546,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool load_segments( std::istream& stream, bool is_lazy ) bool load_segments( std::istream& stream, bool is_lazy ) noexcept
{ {
unsigned char file_class = header->get_class(); unsigned char file_class = header->get_class();
Elf_Half entry_size = header->get_segment_entry_size(); Elf_Half entry_size = header->get_segment_entry_size();
@ -551,12 +562,14 @@ class elfio
for ( Elf_Half i = 0; i < num; ++i ) { for ( Elf_Half i = 0; i < num; ++i ) {
if ( file_class == ELFCLASS64 ) { if ( file_class == ELFCLASS64 ) {
segments_.emplace_back( new segment_impl<Elf64_Phdr>( segments_.emplace_back(
&convertor, &addr_translator ) ); new ( std::nothrow ) segment_impl<Elf64_Phdr>(
&convertor, &addr_translator ) );
} }
else if ( file_class == ELFCLASS32 ) { else if ( file_class == ELFCLASS32 ) {
segments_.emplace_back( new segment_impl<Elf32_Phdr>( segments_.emplace_back(
&convertor, &addr_translator ) ); new ( std::nothrow ) segment_impl<Elf32_Phdr>(
&convertor, &addr_translator ) );
} }
else { else {
segments_.pop_back(); segments_.pop_back();
@ -565,9 +578,10 @@ class elfio
segment* seg = segments_.back().get(); segment* seg = segments_.back().get();
if ( !seg->load( stream, static_cast<std::streamoff>( offset ) + if ( !seg->load( stream,
static_cast<std::streampos>( i ) * static_cast<std::streamoff>( offset ) +
entry_size, is_lazy ) || static_cast<std::streampos>( i ) * entry_size,
is_lazy ) ||
stream.fail() ) { stream.fail() ) {
segments_.pop_back(); segments_.pop_back();
return false; return false;
@ -600,10 +614,13 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool save_header( std::ostream& stream ) { return header->save( stream ); } bool save_header( std::ostream& stream ) const noexcept
{
return header->save( stream );
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool save_sections( std::ostream& stream ) bool save_sections( std::ostream& stream ) const noexcept
{ {
for ( const auto& sec : sections_ ) { for ( const auto& sec : sections_ ) {
std::streampos headerPosition = std::streampos headerPosition =
@ -618,7 +635,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool save_segments( std::ostream& stream ) bool save_segments( std::ostream& stream ) const noexcept
{ {
for ( const auto& seg : segments_ ) { for ( const auto& seg : segments_ ) {
std::streampos headerPosition = std::streampos headerPosition =
@ -633,7 +650,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool is_section_without_segment( unsigned int section_index ) const bool is_section_without_segment( unsigned int section_index ) const noexcept
{ {
bool found = false; bool found = false;
@ -648,7 +665,8 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static bool is_subsequence_of( const segment* seg1, const segment* seg2 ) static bool is_subsequence_of( const segment* seg1,
const segment* seg2 ) noexcept
{ {
// Return 'true' if sections of seg1 are a subset of sections in seg2 // Return 'true' if sections of seg1 are a subset of sections in seg2
const std::vector<Elf_Half>& sections1 = seg1->get_sections(); const std::vector<Elf_Half>& sections1 = seg1->get_sections();
@ -664,7 +682,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::vector<segment*> get_ordered_segments() std::vector<segment*> get_ordered_segments() const noexcept
{ {
std::vector<segment*> res; std::vector<segment*> res;
std::deque<segment*> worklist; std::deque<segment*> worklist;
@ -710,7 +728,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool layout_sections_without_segments() bool layout_sections_without_segments() noexcept
{ {
for ( unsigned int i = 0; i < sections_.size(); ++i ) { for ( unsigned int i = 0; i < sections_.size(); ++i ) {
if ( is_section_without_segment( i ) ) { if ( is_section_without_segment( i ) ) {
@ -738,7 +756,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void calc_segment_alignment() void calc_segment_alignment() const noexcept
{ {
for ( const auto& seg : segments_ ) { for ( const auto& seg : segments_ ) {
for ( Elf_Half i = 0; i < seg->get_sections_num(); ++i ) { for ( Elf_Half i = 0; i < seg->get_sections_num(); ++i ) {
@ -751,7 +769,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool layout_segments_and_their_sections() bool layout_segments_and_their_sections() noexcept
{ {
std::vector<segment*> worklist; std::vector<segment*> worklist;
std::vector<bool> section_generated( sections.size(), false ); std::vector<bool> section_generated( sections.size(), false );
@ -820,7 +838,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool layout_section_table() bool layout_section_table() noexcept
{ {
// Simply place the section table at the end for now // Simply place the section table at the end for now
Elf64_Off alignmentError = current_file_pos % 4; Elf64_Off alignmentError = current_file_pos % 4;
@ -834,7 +852,7 @@ class elfio
std::vector<bool>& section_generated, std::vector<bool>& section_generated,
Elf_Xword& segment_memory, Elf_Xword& segment_memory,
Elf_Xword& segment_filesize, Elf_Xword& segment_filesize,
const Elf_Xword& seg_start_pos ) const Elf_Xword& seg_start_pos ) noexcept
{ {
for ( Elf_Half j = 0; j < seg->get_sections_num(); ++j ) { for ( Elf_Half j = 0; j < seg->get_sections_num(); ++j ) {
Elf_Half index = seg->get_section_index_at( j ); Elf_Half index = seg->get_section_index_at( j );
@ -931,13 +949,13 @@ class elfio
explicit Sections( elfio* parent ) : parent( parent ) {} explicit Sections( elfio* parent ) : parent( parent ) {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Elf_Half size() const Elf_Half size() const noexcept
{ {
return static_cast<Elf_Half>( parent->sections_.size() ); return static_cast<Elf_Half>( parent->sections_.size() );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
section* operator[]( unsigned int index ) const section* operator[]( unsigned int index ) const noexcept
{ {
section* sec = nullptr; section* sec = nullptr;
@ -949,7 +967,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
section* operator[]( const std::string& name ) const section* operator[]( const std::string& name ) const noexcept
{ {
section* sec = nullptr; section* sec = nullptr;
@ -964,7 +982,7 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
section* add( const std::string& name ) section* add( const std::string& name ) const noexcept
{ {
section* new_section = parent->create_section(); section* new_section = parent->create_section();
new_section->set_name( name ); new_section->set_name( name );
@ -979,25 +997,27 @@ class elfio
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::vector<std::unique_ptr<section>>::iterator begin() std::vector<std::unique_ptr<section>>::iterator begin() noexcept
{ {
return parent->sections_.begin(); return parent->sections_.begin();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::vector<std::unique_ptr<section>>::iterator end() std::vector<std::unique_ptr<section>>::iterator end() noexcept
{ {
return parent->sections_.end(); return parent->sections_.end();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::vector<std::unique_ptr<section>>::const_iterator begin() const std::vector<std::unique_ptr<section>>::const_iterator
begin() const noexcept
{ {
return parent->sections_.cbegin(); return parent->sections_.cbegin();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::vector<std::unique_ptr<section>>::const_iterator end() const std::vector<std::unique_ptr<section>>::const_iterator
end() const noexcept
{ {
return parent->sections_.cend(); return parent->sections_.cend();
} }
@ -1017,40 +1037,42 @@ class elfio
explicit Segments( elfio* parent ) : parent( parent ) {} explicit Segments( elfio* parent ) : parent( parent ) {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Elf_Half size() const Elf_Half size() const noexcept
{ {
return static_cast<Elf_Half>( parent->segments_.size() ); return static_cast<Elf_Half>( parent->segments_.size() );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
segment* operator[]( unsigned int index ) const segment* operator[]( unsigned int index ) const noexcept
{ {
return parent->segments_[index].get(); return parent->segments_[index].get();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
segment* add() { return parent->create_segment(); } segment* add() noexcept { return parent->create_segment(); }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::vector<std::unique_ptr<segment>>::iterator begin() std::vector<std::unique_ptr<segment>>::iterator begin() noexcept
{ {
return parent->segments_.begin(); return parent->segments_.begin();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::vector<std::unique_ptr<segment>>::iterator end() std::vector<std::unique_ptr<segment>>::iterator end() noexcept
{ {
return parent->segments_.end(); return parent->segments_.end();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::vector<std::unique_ptr<segment>>::const_iterator begin() const std::vector<std::unique_ptr<segment>>::const_iterator
begin() const noexcept
{ {
return parent->segments_.cbegin(); return parent->segments_.cbegin();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::vector<std::unique_ptr<segment>>::const_iterator end() const std::vector<std::unique_ptr<segment>>::const_iterator
end() const noexcept
{ {
return parent->segments_.cend(); return parent->segments_.cend();
} }
@ -1063,7 +1085,8 @@ class elfio
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
private: private:
std::unique_ptr<elf_header> header = nullptr; std::ifstream* pstream = nullptr;
std::unique_ptr<elf_header> header = nullptr;
std::vector<std::unique_ptr<section>> sections_; std::vector<std::unique_ptr<section>> sections_;
std::vector<std::unique_ptr<segment>> segments_; std::vector<std::unique_ptr<segment>> segments_;
endianess_convertor convertor; endianess_convertor convertor;

10
elfio/elfio_section.hpp
View File

@ -94,19 +94,19 @@ template <class T> class section_impl : public section
ELFIO_GET_ACCESS( Elf64_Addr, address, header.sh_addr ); ELFIO_GET_ACCESS( Elf64_Addr, address, header.sh_addr );
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Elf_Half get_index() const override { return index; } Elf_Half get_index() const noexcept override { return index; }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
std::string get_name() const override { return name; } std::string get_name() const noexcept override { return name; }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void set_name( const std::string& name_prm ) override void set_name( const std::string& name_prm ) noexcept override
{ {
this->name = name_prm; this->name = name_prm;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void set_address( const Elf64_Addr& value ) override void set_address( const Elf64_Addr& value ) noexcept override
{ {
header.sh_addr = decltype( header.sh_addr )( value ); header.sh_addr = decltype( header.sh_addr )( value );
header.sh_addr = ( *convertor )( header.sh_addr ); header.sh_addr = ( *convertor )( header.sh_addr );
@ -193,7 +193,7 @@ template <class T> class section_impl : public section
ELFIO_GET_SET_ACCESS( Elf64_Off, offset, header.sh_offset ); ELFIO_GET_SET_ACCESS( Elf64_Off, offset, header.sh_offset );
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void set_index( const Elf_Half& value ) override { index = value; } void set_index( const Elf_Half& value ) noexcept override { index = value; }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool load( std::istream& stream, std::streampos header_offset ) override bool load( std::istream& stream, std::streampos header_offset ) override

14
elfio/elfio_segment.hpp
View File

@ -64,7 +64,7 @@ class segment
virtual bool load( std::istream& stream, virtual bool load( std::istream& stream,
std::streampos header_offset, std::streampos header_offset,
bool is_lazy = false ) = 0; bool is_lazy ) = 0;
virtual void save( std::ostream& stream, virtual void save( std::ostream& stream,
std::streampos header_offset, std::streampos header_offset,
std::streampos data_offset ) = 0; std::streampos data_offset ) = 0;
@ -93,7 +93,7 @@ template <class T> class segment_impl : public segment
ELFIO_GET_ACCESS( Elf64_Off, offset, ph.p_offset ); ELFIO_GET_ACCESS( Elf64_Off, offset, ph.p_offset );
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Elf_Half get_index() const override { return index; } Elf_Half get_index() const noexcept override { return index; }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
const char* get_data() const override const char* get_data() const override
@ -144,7 +144,7 @@ template <class T> class segment_impl : public segment
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void set_offset( const Elf64_Off& value ) override void set_offset( const Elf64_Off& value ) noexcept override
{ {
ph.p_offset = decltype( ph.p_offset )( value ); ph.p_offset = decltype( ph.p_offset )( value );
ph.p_offset = ( *convertor )( ph.p_offset ); ph.p_offset = ( *convertor )( ph.p_offset );
@ -161,12 +161,12 @@ template <class T> class segment_impl : public segment
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void set_index( const Elf_Half& value ) override { index = value; } void set_index( const Elf_Half& value ) noexcept override { index = value; }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool load( std::istream& stream, bool load( std::istream& stream,
std::streampos header_offset, std::streampos header_offset,
bool is_lazy_ = false ) override bool is_lazy_ ) override
{ {
pstream = &stream; pstream = &stream;
is_lazy = is_lazy_; is_lazy = is_lazy_;
@ -190,6 +190,7 @@ template <class T> class segment_impl : public segment
return true; return true;
} }
//------------------------------------------------------------------------------
bool load_data() const bool load_data() const
{ {
if ( PT_NULL == get_type() || 0 == get_file_size() ) { if ( PT_NULL == get_type() || 0 == get_file_size() ) {
@ -199,7 +200,7 @@ template <class T> class segment_impl : public segment
pstream->seekg( ( *translator )[( *convertor )( ph.p_offset )] ); pstream->seekg( ( *translator )[( *convertor )( ph.p_offset )] );
Elf_Xword size = get_file_size(); Elf_Xword size = get_file_size();
if ( size > get_stream_size() || is_lazy ) { if ( size > get_stream_size() ) {
data = nullptr; data = nullptr;
} }
else { else {
@ -207,6 +208,7 @@ template <class T> class segment_impl : public segment
if ( nullptr != data.get() && pstream->read( data.get(), size ) ) { if ( nullptr != data.get() && pstream->read( data.get(), size ) ) {
data.get()[size] = 0; data.get()[size] = 0;
is_lazy = false;
} }
else { else {
data = nullptr; data = nullptr;

43
elfio/elfio_utils.hpp
View File

@ -26,30 +26,37 @@ THE SOFTWARE.
#include <cstdint> #include <cstdint>
#include <ostream> #include <ostream>
#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 noexcept = 0
#define ELFIO_SET_ACCESS_DECL( TYPE, NAME ) \ #define ELFIO_SET_ACCESS_DECL( TYPE, NAME ) \
virtual void set_##NAME( const TYPE& value ) = 0 virtual void set_##NAME( const TYPE& value ) noexcept = 0
#define ELFIO_GET_SET_ACCESS_DECL( TYPE, NAME ) \ #define ELFIO_GET_SET_ACCESS_DECL( TYPE, NAME ) \
virtual TYPE get_##NAME() const = 0; \ virtual TYPE get_##NAME() const noexcept = 0; \
virtual void set_##NAME( const TYPE& value ) = 0 virtual void set_##NAME( const TYPE& value ) noexcept = 0
#define ELFIO_GET_ACCESS( TYPE, NAME, FIELD ) \ #define ELFIO_GET_ACCESS( TYPE, NAME, FIELD ) \
TYPE get_##NAME() const override { return ( *convertor )( FIELD ); } TYPE get_##NAME() const noexcept override \
{ \
#define ELFIO_SET_ACCESS( TYPE, NAME, FIELD ) \ return ( *convertor )( FIELD ); \
void set_##NAME( const TYPE& value ) override \
{ \
FIELD = decltype( FIELD )( value ); \
FIELD = ( *convertor )( FIELD ); \
} }
#define ELFIO_GET_SET_ACCESS( TYPE, NAME, FIELD ) \
TYPE get_##NAME() const override { return ( *convertor )( FIELD ); } \ #define ELFIO_SET_ACCESS( TYPE, NAME, FIELD ) \
void set_##NAME( const TYPE& value ) override \ void set_##NAME( const TYPE& value ) noexcept override \
{ \ { \
FIELD = decltype( FIELD )( value ); \ FIELD = decltype( FIELD )( value ); \
FIELD = ( *convertor )( FIELD ); \ FIELD = ( *convertor )( FIELD ); \
}
#define ELFIO_GET_SET_ACCESS( TYPE, NAME, FIELD ) \
TYPE get_##NAME() const noexcept override \
{ \
return ( *convertor )( FIELD ); \
} \
void set_##NAME( const TYPE& value ) noexcept override \
{ \
FIELD = decltype( FIELD )( value ); \
FIELD = ( *convertor )( FIELD ); \
} }
namespace ELFIO { namespace ELFIO {

18
examples/c_wrapper/elfio_c_wrapper.cpp
View File

@ -34,7 +34,7 @@ using namespace ELFIO;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// elfio // elfio
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
pelfio_t elfio_new() { return new elfio; } pelfio_t elfio_new() { return new ( std::nothrow ) elfio; }
void elfio_delete( pelfio_t pelfio ) { delete (elfio*)pelfio; } void elfio_delete( pelfio_t pelfio ) { delete (elfio*)pelfio; }
@ -209,7 +209,7 @@ bool elfio_segment_is_offset_initialized( psegment_t psegment )
psymbol_t elfio_symbol_section_accessor_new( pelfio_t pelfio, psymbol_t elfio_symbol_section_accessor_new( pelfio_t pelfio,
psection_t psection ) psection_t psection )
{ {
return new symbol_section_accessor( *pelfio, psection ); return new ( std::nothrow ) symbol_section_accessor( *pelfio, psection );
} }
void elfio_symbol_section_accessor_delete( psymbol_t psymbol ) void elfio_symbol_section_accessor_delete( psymbol_t psymbol )
@ -264,7 +264,8 @@ Elf_Xword elfio_symbol_arrange_local_symbols(
prelocation_t elfio_relocation_section_accessor_new( pelfio_t pelfio, prelocation_t elfio_relocation_section_accessor_new( pelfio_t pelfio,
psection_t psection ) psection_t psection )
{ {
return new relocation_section_accessor( *pelfio, psection ); return new ( std::nothrow )
relocation_section_accessor( *pelfio, psection );
} }
void elfio_relocation_section_accessor_delete( prelocation_t prelocation ) void elfio_relocation_section_accessor_delete( prelocation_t prelocation )
@ -318,7 +319,7 @@ void elfio_relocation_swap_symbols( prelocation_t prelocation,
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
pstring_t elfio_string_section_accessor_new( psection_t psection ) pstring_t elfio_string_section_accessor_new( psection_t psection )
{ {
return new string_section_accessor( psection ); return new ( std::nothrow ) string_section_accessor( psection );
} }
void elfio_string_section_accessor_delete( pstring_t pstring ) void elfio_string_section_accessor_delete( pstring_t pstring )
@ -341,7 +342,7 @@ Elf_Word elfio_string_add_string( pstring_t pstring, char* str )
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
pnote_t elfio_note_section_accessor_new( pelfio_t pelfio, psection_t psection ) pnote_t elfio_note_section_accessor_new( pelfio_t pelfio, psection_t psection )
{ {
return new note_section_accessor( *pelfio, psection ); return new ( std::nothrow ) note_section_accessor( *pelfio, psection );
} }
void elfio_note_section_accessor_delete( pnote_t pnote ) { delete pnote; } void elfio_note_section_accessor_delete( pnote_t pnote ) { delete pnote; }
@ -380,7 +381,7 @@ void elfio_note_add_note( pnote_t pnote,
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
pmodinfo_t elfio_modinfo_section_accessor_new( psection_t psection ) pmodinfo_t elfio_modinfo_section_accessor_new( psection_t psection )
{ {
return new modinfo_section_accessor( psection ); return new ( std::nothrow ) modinfo_section_accessor( psection );
} }
void elfio_modinfo_section_accessor_delete( pmodinfo_t pmodinfo ) void elfio_modinfo_section_accessor_delete( pmodinfo_t pmodinfo )
@ -433,7 +434,7 @@ elfio_modinfo_add_attribute( pmodinfo_t pmodinfo, char* field, char* value )
pdynamic_t elfio_dynamic_section_accessor_new( pelfio_t pelfio, pdynamic_t elfio_dynamic_section_accessor_new( pelfio_t pelfio,
psection_t psection ) psection_t psection )
{ {
return new dynamic_section_accessor( *pelfio, psection ); return new ( std::nothrow ) dynamic_section_accessor( *pelfio, psection );
} }
void elfio_dynamic_section_accessor_delete( pdynamic_t pdynamic ) void elfio_dynamic_section_accessor_delete( pdynamic_t pdynamic )
@ -473,7 +474,8 @@ void elfio_dynamic_add_entry( pdynamic_t pdynamic,
parray_t elfio_array_section_accessor_new( pelfio_t pelfio, parray_t elfio_array_section_accessor_new( pelfio_t pelfio,
psection_t psection ) psection_t psection )
{ {
return new array_section_accessor<Elf64_Word>( *pelfio, psection ); return new ( std::nothrow )
array_section_accessor<Elf64_Word>( *pelfio, psection );
} }
void elfio_array_section_accessor_delete( parray_t parray ) { delete parray; } void elfio_array_section_accessor_delete( parray_t parray ) { delete parray; }

8
tests/ELFIOTest.cpp
View File

@ -981,7 +981,8 @@ class mock_wiiu_compression : public compression_interface
Elf_Xword& uncompressed_size ) const override Elf_Xword& uncompressed_size ) const override
{ {
uncompressed_size = 2 * compressed_size; uncompressed_size = 2 * compressed_size;
return std::unique_ptr<char[]>( new char[uncompressed_size + 1] ); return std::unique_ptr<char[]>(
new ( std::nothrow ) char[uncompressed_size + 1] );
} }
std::unique_ptr<char[]> deflate( const char* data, std::unique_ptr<char[]> deflate( const char* data,
@ -990,7 +991,8 @@ class mock_wiiu_compression : public compression_interface
Elf_Xword& compressed_size ) const override Elf_Xword& compressed_size ) const override
{ {
compressed_size = decompressed_size / 2; compressed_size = decompressed_size / 2;
return std::unique_ptr<char[]>( new char[compressed_size + 1] ); return std::unique_ptr<char[]>(
new ( std::nothrow ) char[compressed_size + 1] );
} }
}; };
@ -1005,7 +1007,7 @@ class mock_wiiu_compression : public compression_interface
// a real compression implementation // a real compression implementation
TEST( ELFIOTest, test_rpx ) TEST( ELFIOTest, test_rpx )
{ {
elfio reader( new mock_wiiu_compression() ); elfio reader( new ( std::nothrow ) mock_wiiu_compression() );
elfio reader_no_compression; elfio reader_no_compression;
ASSERT_EQ( reader_no_compression.load( "elf_examples/helloworld.rpx" ), ASSERT_EQ( reader_no_compression.load( "elf_examples/helloworld.rpx" ),