README

-ELFIO is a header-only C++ library intended for reading and generating
-files in the ELF binary format. It is used as a standalone library - it is not
-dependant on any other product or project. Adhering to ISO C++, it compiles on
-a wide variety of architectures and compilers.

README.md

+# ELFIO
+
+![C/C++ CI](https://github.com/serge1/ELFIO/workflows/C/C++%20CI/badge.svg)
+![CodeQL](https://github.com/serge1/ELFIO/workflows/CodeQL/badge.svg)
+[![Documentation](https://img.shields.io/badge/doc-download-brightgreen)](http://elfio.sourceforge.net/elfio.pdf)
+[![License](https://img.shields.io/badge/License-MIT-brightgreen.svg)](https://github.com/serge1/ELFIO/blob/master/COPYING)
+
+ELFIO is a header-only C++ library intended for reading and generating
+files in the ELF binary format. It is used as a standalone library - it is not
+dependent on any other product or project. Adhering to ISO C++, it compiles on
+a wide variety of architectures and compilers.
+
+While written in C++, the library also provides a C-language interface wrapper.
+
+The full library documentation can be found in *[ELFIO - Tutorial and User Manual](http://elfio.sourceforge.net/elfio.pdf)*.

cmake/elfioConfig.cmake.in

+# Basic CMake package config file
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
+check_required_components("@PROJECT_NAME@")
\ No newline at end of file

configure.ac

-AC_INIT([ELFIO], [3.2])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign])
-AC_PROG_CXX
-AC_CONFIG_FILES([
-           Makefile
-           examples/Makefile
-           examples/elfdump/Makefile
-           examples/tutorial/Makefile
-           examples/writer/Makefile
-           examples/write_obj/Makefile
-])
-AC_OUTPUT

cygwin/elfio.cygport

-inherit python python3
-
-NAME="ELFIO"
-VERSION=3.2
-RELEASE=1
-CATEGORY="Devel System Libs"
-SUMMARY="ELFIO is a header-only C++ library intended for reading and generating
-files in the ELF binary format"
-DESCRIPTION="ELFIO is a small, header-only C++ library that provides a simple
-interface for reading and generating files in ELF binary format. It is used
-as a standalone library - it is not dependant on any other product or project.
-Adhering to ISO C++, it compiles on a wide variety of architectures
-and compilers."
-
-HOMEPAGE="http://elfio.sourceforge.net/"
-SRC_URI="https://sourceforge.net/projects/elfio/files/ELFIO-sources/${PN}-${PV}/elfio-${PV}.tar.gz"
-SRC_DIR="${PN}-${PV}"
-
-PKG_NAMES="ELFIO"
-ELFIO_REQUIRES="cygwin"
-ELFIO_CONTENTS="usr/include/ usr/share/${PN}"
-ELFIO_DOCS='AUTHORS COPYING README doc/elfio.pdf'
-
-src_compile() {
-	cd ${B}
-}
-
-src_install() {
-	cd ${B}
-	dodir /usr/include
-	cp -r ${S}/elfio ${D}/usr/include/
-
-	dodir /usr/share/${PN}
-	cp -r ${S}/configure ${S}/depcomp ${S}/install-sh ${S}/missing \
-	      ${S}/configure.ac ${S}/Makefile.am ${S}/Makefile.in ${S}/aclocal.m4 \
-	      ${S}/examples \
-	      ${D}/usr/share/${PN}
-}

doc/site/index.htm

@@ -19,12 +19,24 @@
 <div class="links">
 <h3>Links</h3>
 <ul class="menu">
-<li><a href="http://sourceforge.net/projects/elfio/files/">Download</a> the source
-    distribution</li><br/>
+
+<li>Download the source distribution from
+<a href="http://sourceforge.net/projects/elfio/files/">SourceForge</a>
+or
+<a href="https://github.com/serge1/ELFIO/releases">GitHub</a>
+repositories
+</li><br/>
+
 <li>Read the <a href="elfio.pdf">Tutorial and User Manual</a></li><br/>
+
+<li>Visit the
+<a href="https://github.com/serge1/ELFIO">GitHub project page</a></li><br/>
+
 <li>Visit the
 <a href="http://sourceforge.net/projects/elfio/">SourceForge project page</a></li><br/>
+
 <li><a href="oldsite/index.htm">Old documentation</a> for outdated 1.0.3 version of the library</li><br/>
+
 <li>Send <a href="mailto:to_serge@users.sourceforge.net">feedback, comments, patches, etc.</a></li></br>
 </ul>
 </div>
@@ -36,20 +48,20 @@
 reading and generating files in ELF binary format.
 </p>
 <p>
-It is used as a standalone library - it is not dependant on any other product
+It is used as a standalone library - it is not dependent on any other product
 or project. Adhering to ISO C++, it compiles on a wide variety of architectures
 and compilers.
 </p>
 <p>
 While the library is easy to use, some basic knowledge of the ELF binary format
-is required. Such Information can easily be found on the Web.
+is required. Such Information can be easily found on the Web.
 </p>
 <p>
-Current version of <em>ELFIO</em> library is 2.x and it is distributed under
+The current version of <em>ELFIO</em> library is 3.x and it is distributed under
 <a href="http://www.opensource.org/licenses/MIT">MIT License</a> conditions.
 </p>
 <p>
-Note for users of previous library versions 1.0.x: Version 2.x is not source
+Note for users of previous library versions 1.0.x: Version 3.x is not source
 compatible to earlier versions. Transition to the new library interface is
 straightforward though.
 </p>

elfio/elfio_array.hpp

+/*
+Copyright (C) 2001-present by Serge Lamikhov-Center
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef ELFIO_ARRAY_HPP
+#define ELFIO_ARRAY_HPP
+
+#include <algorithm>
+
+namespace ELFIO {
+
+//------------------------------------------------------------------------------
+template <class S, typename T> class array_section_accessor_template
+{
+  public:
+    //------------------------------------------------------------------------------
+    explicit array_section_accessor_template( const elfio& elf_file,
+                                              S*           section )
+        : elf_file( elf_file ), array_section( section )
+    {
+    }
+
+    //------------------------------------------------------------------------------
+    Elf_Xword get_entries_num() const
+    {
+        Elf_Xword entry_size = sizeof( T );
+        return array_section->get_size() / entry_size;
+    }
+
+    //------------------------------------------------------------------------------
+    bool get_entry( Elf_Xword index, Elf64_Addr& address ) const
+    {
+        if ( index >= get_entries_num() ) { // Is index valid
+            return false;
+        }
+
+        const endianess_convertor& convertor = elf_file.get_convertor();
+
+        const T temp = *reinterpret_cast<const T*>( array_section->get_data() +
+                                                    index * sizeof( T ) );
+        address      = convertor( temp );
+
+        return true;
+    }
+
+    //------------------------------------------------------------------------------
+    void add_entry( Elf64_Addr address )
+    {
+        const endianess_convertor& convertor = elf_file.get_convertor();
+
+        T temp = convertor( (T)address );
+        array_section->append_data( reinterpret_cast<char*>( &temp ),
+                                    sizeof( temp ) );
+    }
+
+  private:
+    //------------------------------------------------------------------------------
+    const elfio& elf_file;
+    S*           array_section;
+};
+
+template <typename T = Elf32_Word>
+using array_section_accessor = array_section_accessor_template<section, T>;
+template <typename T = Elf32_Word>
+using const_array_section_accessor =
+    array_section_accessor_template<const section, T>;
+
+} // namespace ELFIO
+
+#endif // ELFIO_ARRAY_HPP

elfio/elfio_dynamic.hpp

 /*
-Copyright (C) 2001-2015 by Serge Lamikhov-Center
+Copyright (C) 2001-present by Serge Lamikhov-Center
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,59 +23,76 @@ THE SOFTWARE.
 #ifndef ELFIO_DYNAMIC_HPP
 #define ELFIO_DYNAMIC_HPP
 
+#include <algorithm>
+
 namespace ELFIO {
 
 //------------------------------------------------------------------------------
-class dynamic_section_accessor
+template <class S> class dynamic_section_accessor_template
 {
   public:
-//------------------------------------------------------------------------------
-    dynamic_section_accessor( const elfio& elf_file_, section* section_ ) :
-                              elf_file( elf_file_ ),
-                              dynamic_section( section_ )
+    //------------------------------------------------------------------------------
+    explicit dynamic_section_accessor_template( const elfio& elf_file,
+                                                S*           section )
+        : elf_file( elf_file ), dynamic_section( section ), entries_num( 0 )
     {
     }
 
-//------------------------------------------------------------------------------
-    Elf_Xword
-    get_entries_num() const
+    //------------------------------------------------------------------------------
+    Elf_Xword get_entries_num() const
     {
-        Elf_Xword nRet = 0;
+        size_t needed_entry_size = -1;
+        if ( elf_file.get_class() == ELFCLASS32 ) {
+            needed_entry_size = sizeof( Elf32_Dyn );
+        }
+        else {
+            needed_entry_size = sizeof( Elf64_Dyn );
+        }
 
-        if ( 0 != dynamic_section->get_entry_size() ) {
-            nRet = dynamic_section->get_size() / dynamic_section->get_entry_size();
+        if ( ( 0 == entries_num ) &&
+             ( 0 != dynamic_section->get_entry_size() &&
+               dynamic_section->get_entry_size() >= needed_entry_size ) ) {
+            entries_num =
+                dynamic_section->get_size() / dynamic_section->get_entry_size();
+            Elf_Xword   i;
+            Elf_Xword   tag   = DT_NULL;
+            Elf_Xword   value = 0;
+            std::string str;
+            for ( i = 0; i < entries_num; i++ ) {
+                get_entry( i, tag, value, str );
+                if ( tag == DT_NULL )
+                    break;
+            }
+            entries_num = std::min<Elf_Xword>( entries_num, i + 1 );
         }
 
-        return nRet;
+        return entries_num;
     }
 
-//------------------------------------------------------------------------------
-    bool
-    get_entry( Elf_Xword    index,
-               Elf_Xword&   tag,
-               Elf_Xword&   value,
-               std::string& str ) const
+    //------------------------------------------------------------------------------
+    bool get_entry( Elf_Xword    index,
+                    Elf_Xword&   tag,
+                    Elf_Xword&   value,
+                    std::string& str ) const
     {
-        if ( index >= get_entries_num() ) {    // Is index valid
+        if ( index >= get_entries_num() ) { // Is index valid
             return false;
         }
 
         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 the tag has a string table reference - prepare the string
+        if ( tag == DT_NEEDED || tag == DT_SONAME || tag == DT_RPATH ||
              tag == DT_RUNPATH ) {
-            string_section_accessor strsec =
-                elf_file.sections[ get_string_table_index() ];
-            const char* result = strsec.get_string( value );
-            if ( 0 == result ) {
+            string_section_accessor strsec(
+                elf_file.sections[get_string_table_index()] );
+            const char* result = strsec.get_string( (Elf_Word)value );
+            if ( nullptr == result ) {
                 str.clear();
                 return false;
             }
@@ -88,59 +105,55 @@ class dynamic_section_accessor
         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_dyn<Elf32_Dyn>( tag, value );
         }
         else {
-            generic_add_entry< Elf64_Dyn >( tag, value );
+            generic_add_entry_dyn<Elf64_Dyn>( tag, value );
         }
     }
 
-//------------------------------------------------------------------------------
-    void
-    add_entry( Elf_Xword&   tag,
-               std::string& str )
+    //------------------------------------------------------------------------------
+    void add_entry( Elf_Xword tag, const std::string& str )
     {
-        string_section_accessor strsec =
-            elf_file.sections[ get_string_table_index() ];
+        string_section_accessor strsec(
+            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,
-                           Elf_Xword& tag,
-                           Elf_Xword& value ) const
+    //------------------------------------------------------------------------------
+    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() == nullptr ||
+             ( index + 1 ) * dynamic_section->get_entry_size() >
+                 dynamic_section->get_size() ||
+             dynamic_section->get_entry_size() < sizeof( T ) ) {
             tag   = DT_NULL;
             value = 0;
             return;
         }
 
         const T* pEntry = reinterpret_cast<const T*>(
-                dynamic_section->get_data() +
-                index * dynamic_section->get_entry_size() );
+            dynamic_section->get_data() +
+            index * dynamic_section->get_entry_size() );
         tag = convertor( pEntry->d_tag );
         switch ( tag ) {
         case DT_NULL:
@@ -186,10 +199,9 @@ class dynamic_section_accessor
         }
     }
 
-//------------------------------------------------------------------------------
-    template< class T >
-    void
-    generic_add_entry( Elf_Xword tag, Elf_Xword value )
+    //------------------------------------------------------------------------------
+    template <class T>
+    void generic_add_entry_dyn( Elf_Xword tag, Elf_Xword value )
     {
         const endianess_convertor& convertor = elf_file.get_convertor();
 
@@ -200,7 +212,8 @@ class dynamic_section_accessor
         case DT_SYMBOLIC:
         case DT_TEXTREL:
         case DT_BIND_NOW:
-            value = 0;
+            entry.d_un.d_val = convertor( decltype( entry.d_un.d_val )( 0 ) );
+            break;
         case DT_NEEDED:
         case DT_PLTRELSZ:
         case DT_RELASZ:
@@ -217,7 +230,8 @@ class dynamic_section_accessor
         case DT_RUNPATH:
         case DT_FLAGS:
         case DT_PREINIT_ARRAYSZ:
-            entry.d_un.d_val = convertor( value );
+            entry.d_un.d_val =
+                convertor( decltype( entry.d_un.d_val )( value ) );
             break;
         case DT_PLTGOT:
         case DT_HASH:
@@ -233,21 +247,28 @@ class dynamic_section_accessor
         case DT_FINI_ARRAY:
         case DT_PREINIT_ARRAY:
         default:
-            entry.d_un.d_ptr = convertor( value );
+            entry.d_un.d_ptr =
+                convertor( decltype( entry.d_un.d_val )( value ) );
             break;
         }
 
-        entry.d_tag = convertor( tag );
+        entry.d_tag = convertor( decltype( entry.d_tag )( 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;
-    section*     dynamic_section;
+    const elfio&      elf_file;
+    S*                dynamic_section;
+    mutable Elf_Xword entries_num;
 };
 
+using dynamic_section_accessor = dynamic_section_accessor_template<section>;
+using const_dynamic_section_accessor =
+    dynamic_section_accessor_template<const section>;
+
 } // namespace ELFIO
 
 #endif // ELFIO_DYNAMIC_HPP

elfio/elfio_header.hpp

 /*
-Copyright (C) 2001-2015 by Serge Lamikhov-Center
+Copyright (C) 2001-present by Serge Lamikhov-Center
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -30,55 +30,56 @@ namespace ELFIO {
 class elf_header
 {
   public:
-    virtual ~elf_header() {};
+    virtual ~elf_header() = default;
+
     virtual bool load( std::istream& stream )       = 0;
     virtual bool save( std::ostream& stream ) const = 0;
 
     // ELF header functions
-    ELFIO_GET_ACCESS_DECL( unsigned char, class              );
-    ELFIO_GET_ACCESS_DECL( unsigned char, elf_version        );
-    ELFIO_GET_ACCESS_DECL( unsigned char, encoding           );
-    ELFIO_GET_ACCESS_DECL( Elf_Word,      version            );
-    ELFIO_GET_ACCESS_DECL( Elf_Half,      header_size        );
-    ELFIO_GET_ACCESS_DECL( Elf_Half,      section_entry_size );
-    ELFIO_GET_ACCESS_DECL( Elf_Half,      segment_entry_size );
-
-    ELFIO_GET_SET_ACCESS_DECL( unsigned char, os_abi          );
-    ELFIO_GET_SET_ACCESS_DECL( unsigned char, abi_version     );
-    ELFIO_GET_SET_ACCESS_DECL( Elf_Half,      type            );
-    ELFIO_GET_SET_ACCESS_DECL( Elf_Half,      machine         );
-    ELFIO_GET_SET_ACCESS_DECL( Elf_Word,      flags           );
-    ELFIO_GET_SET_ACCESS_DECL( Elf64_Addr,    entry           );
-    ELFIO_GET_SET_ACCESS_DECL( Elf_Half,      sections_num    );
-    ELFIO_GET_SET_ACCESS_DECL( Elf64_Off,     sections_offset );
-    ELFIO_GET_SET_ACCESS_DECL( Elf_Half,      segments_num    );
-    ELFIO_GET_SET_ACCESS_DECL( Elf64_Off,     segments_offset );
-    ELFIO_GET_SET_ACCESS_DECL( Elf_Half,      section_name_str_index );
+    ELFIO_GET_ACCESS_DECL( unsigned char, class );
+    ELFIO_GET_ACCESS_DECL( unsigned char, elf_version );
+    ELFIO_GET_ACCESS_DECL( unsigned char, encoding );
+    ELFIO_GET_ACCESS_DECL( Elf_Half, header_size );
+    ELFIO_GET_ACCESS_DECL( Elf_Half, section_entry_size );
+    ELFIO_GET_ACCESS_DECL( Elf_Half, segment_entry_size );
+
+    ELFIO_GET_SET_ACCESS_DECL( Elf_Word, version );
+    ELFIO_GET_SET_ACCESS_DECL( unsigned char, os_abi );
+    ELFIO_GET_SET_ACCESS_DECL( unsigned char, abi_version );
+    ELFIO_GET_SET_ACCESS_DECL( Elf_Half, type );
+    ELFIO_GET_SET_ACCESS_DECL( Elf_Half, machine );
+    ELFIO_GET_SET_ACCESS_DECL( Elf_Word, flags );
+    ELFIO_GET_SET_ACCESS_DECL( Elf64_Addr, entry );
+    ELFIO_GET_SET_ACCESS_DECL( Elf_Half, sections_num );
+    ELFIO_GET_SET_ACCESS_DECL( Elf64_Off, sections_offset );
+    ELFIO_GET_SET_ACCESS_DECL( Elf_Half, segments_num );
+    ELFIO_GET_SET_ACCESS_DECL( Elf64_Off, segments_offset );
+    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> {
-    typedef Elf32_Phdr Phdr_type;
-    typedef Elf32_Shdr Shdr_type;
+template <class T> struct elf_header_impl_types;
+template <> struct elf_header_impl_types<Elf32_Ehdr>
+{
+    using Phdr_type                       = Elf32_Phdr;
+    using Shdr_type                       = Elf32_Shdr;
     static const unsigned char file_class = ELFCLASS32;
 };
-template<> struct elf_header_impl_types<Elf64_Ehdr> {
-    typedef Elf64_Phdr Phdr_type;
-    typedef Elf64_Shdr Shdr_type;
+template <> struct elf_header_impl_types<Elf64_Ehdr>
+{
+    using Phdr_type                       = Elf64_Phdr;
+    using Shdr_type                       = Elf64_Shdr;
     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,
+                     const address_translator* translator )
+        : convertor( convertor ), translator( translator )
     {
-        convertor = convertor_;
-
-        std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ), '\0' );
-
         header.e_ident[EI_MAG0]    = ELFMAG0;
         header.e_ident[EI_MAG1]    = ELFMAG1;
         header.e_ident[EI_MAG2]    = ELFMAG2;
@@ -86,59 +87,65 @@ 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           = EV_CURRENT;
-        header.e_version           = (*convertor)( header.e_version );
+        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 ) override
     {
-        stream.seekg( 0 );
+        stream.seekg( ( *translator )[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 override
     {
-        stream.seekp( 0 );
-        stream.write( reinterpret_cast<const char*>( &header ), sizeof( header ) );
+        stream.seekp( ( *translator )[0] );
+        stream.write( reinterpret_cast<const char*>( &header ),
+                      sizeof( header ) );
 
         return stream.good();
     }
 
+    //------------------------------------------------------------------------------
     // ELF header functions
-    ELFIO_GET_ACCESS( unsigned char, class,              header.e_ident[EI_CLASS] );
-    ELFIO_GET_ACCESS( unsigned char, elf_version,        header.e_ident[EI_VERSION] );
-    ELFIO_GET_ACCESS( unsigned char, encoding,           header.e_ident[EI_DATA] );
-    ELFIO_GET_ACCESS( Elf_Word,      version,            header.e_version );
-    ELFIO_GET_ACCESS( Elf_Half,      header_size,        header.e_ehsize );
-    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( 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( 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 );
-    ELFIO_GET_SET_ACCESS( Elf_Half,      section_name_str_index, header.e_shstrndx );
-    ELFIO_GET_SET_ACCESS( Elf64_Addr,    entry,           header.e_entry );
-    ELFIO_GET_SET_ACCESS( Elf_Half,      sections_num,    header.e_shnum );
-    ELFIO_GET_SET_ACCESS( Elf64_Off,     sections_offset, header.e_shoff );
-    ELFIO_GET_SET_ACCESS( Elf_Half,      segments_num,    header.e_phnum );
-    ELFIO_GET_SET_ACCESS( Elf64_Off,     segments_offset, header.e_phoff );
+    ELFIO_GET_ACCESS( unsigned char, class, header.e_ident[EI_CLASS] );
+    ELFIO_GET_ACCESS( unsigned char, elf_version, header.e_ident[EI_VERSION] );
+    ELFIO_GET_ACCESS( unsigned char, encoding, header.e_ident[EI_DATA] );
+    ELFIO_GET_ACCESS( Elf_Half, header_size, header.e_ehsize );
+    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( 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( 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 );
+    ELFIO_GET_SET_ACCESS( Elf_Half, section_name_str_index, header.e_shstrndx );
+    ELFIO_GET_SET_ACCESS( Elf64_Addr, entry, header.e_entry );
+    ELFIO_GET_SET_ACCESS( Elf_Half, sections_num, header.e_shnum );
+    ELFIO_GET_SET_ACCESS( Elf64_Off, sections_offset, header.e_shoff );
+    ELFIO_GET_SET_ACCESS( Elf_Half, segments_num, header.e_phnum );
+    ELFIO_GET_SET_ACCESS( Elf64_Off, segments_offset, header.e_phoff );
 
   private:
-    T header;
-    endianess_convertor* convertor;
+    T                         header     = {};
+    endianess_convertor*      convertor  = nullptr;
+    const address_translator* translator = nullptr;
 };
 
 } // namespace ELFIO

elfio/elfio_modinfo.hpp

+/*
+Copyright (C) 2001-present by Serge Lamikhov-Center
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef ELFIO_MODINFO_HPP
+#define ELFIO_MODINFO_HPP
+
+#include <string>
+#include <vector>
+
+namespace ELFIO {
+
+//------------------------------------------------------------------------------
+template <class S> class modinfo_section_accessor_template
+{
+  public:
+    //------------------------------------------------------------------------------
+    explicit modinfo_section_accessor_template( S* section )
+        : modinfo_section( section )
+    {
+        process_section();
+    }
+
+    //------------------------------------------------------------------------------
+    Elf_Word get_attribute_num() const { return (Elf_Word)content.size(); }
+
+    //------------------------------------------------------------------------------
+    bool
+    get_attribute( Elf_Word no, std::string& field, std::string& value ) const
+    {
+        if ( no < content.size() ) {
+            field = content[no].first;
+            value = content[no].second;
+            return true;
+        }
+
+        return false;
+    }
+
+    //------------------------------------------------------------------------------
+    bool get_attribute( const std::string& field_name,
+                        std::string&       value ) const
+    {
+        for ( auto& i : content ) {
+            if ( field_name == i.first ) {
+                value = i.second;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    //------------------------------------------------------------------------------
+    Elf_Word add_attribute( const std::string& field, const std::string& value )
+    {
+        Elf_Word current_position = 0;
+
+        if ( modinfo_section ) {
+            // Strings are addeded to the end of the current section data
+            current_position = (Elf_Word)modinfo_section->get_size();
+
+            std::string attribute = field + "=" + value;
+
+            modinfo_section->append_data( attribute + '\0' );
+            content.emplace_back( field, value );
+        }
+
+        return current_position;
+    }
+
+    //------------------------------------------------------------------------------
+  private:
+    void process_section()
+    {
+        const char* pdata = modinfo_section->get_data();
+        if ( pdata ) {
+            ELFIO::Elf_Xword i = 0;
+            while ( i < modinfo_section->get_size() ) {
+                while ( i < modinfo_section->get_size() && !pdata[i] )
+                    i++;
+                if ( i < modinfo_section->get_size() ) {
+                    std::string info = pdata + i;
+                    size_t      loc  = info.find( '=' );
+                    content.emplace_back( info.substr( 0, loc ),
+                                          info.substr( loc + 1 ) );
+
+                    i += info.length();
+                }
+            }
+        }
+    }
+
+    //------------------------------------------------------------------------------
+  private:
+    S*                                               modinfo_section;
+    std::vector<std::pair<std::string, std::string>> content;
+};
+
+using modinfo_section_accessor = modinfo_section_accessor_template<section>;
+using const_modinfo_section_accessor =
+    modinfo_section_accessor_template<const section>;
+
+} // namespace ELFIO
+
+#endif // ELFIO_MODINFO_HPP