ony-ruby-elf 1.1.0

data/lib/elf/dynamic.rb

@@ -0,0 +1,392 @@
+# -*- coding: utf-8 -*-
+# Simple ELF parser for Ruby
+#
+# Copyright © 2007-2010 Diego Elio Pettenò <flameeyes@flameeyes.eu>
+# Portions inspired by elf.py
+#   Copyright © 2002 Netgraft Corporation
+# Portions inspired by elf.h
+#   Copyright © 1995-2006 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this generator; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'elf/utils/loader'
+
+module Elf
+  class Dynamic < Section
+    class Type < Value
+      class Unknown < Elf::Value::Unknown
+        def initialize(val, desc)
+          super(val, desc)
+        end
+
+        # For unknown types, guess Value is the key.
+        def attribute
+          :Value
+        end
+      end
+
+      attr_reader :attribute
+
+      def initialize(val, params)
+        super(val, params)
+
+        @attribute = params[2]
+      end
+
+      fill(
+              0 => [ :Null, "NULL", :Ignore ],
+              1 => [ :Needed, "NEEDED", :Value ],
+              2 => [ :PltRelSz, "PLTRELSZ", :Value ],
+              3 => [ :PltGot, "PLTGOT", :Ignore ],
+              4 => [ :Hash, "HASH", :Address ],
+              5 => [ :StrTab, "STRTAB", :Address ],
+              6 => [ :SymTab, "SYMTAB", :Address ],
+              7 => [ :RelA, "RELA", :Address ],
+              8 => [ :RelASz, "RELASZ", :Value ],
+              9 => [ :RelAEnt, "RELAENT", :Value ],
+             10 => [ :StrSz, "STRSZ", :Value ],
+             11 => [ :SymEnt, "SYMENT", :Value ],
+             12 => [ :Init, "INIT", :Address ],
+             13 => [ :Fini, "FINI", :Address ],
+             14 => [ :SoName, "SONAME", :Value ],
+             15 => [ :RPath, "RPATH", :Value ],
+             16 => [ :Symbolic, "SYMBOLIC", :Ignore ],
+             17 => [ :Rel, "REL", :Address ],
+             18 => [ :RelSz, "RELSZ", :Value ],
+             19 => [ :RelEnt, "RELENT", :Value ],
+             20 => [ :PltRel, "PLTREL", :Value ],
+             21 => [ :Debug, "DEBUG", :Ignore ],
+             22 => [ :TextRel, "TEXTREL", :Ignore ],
+             23 => [ :JmpRel, "JMPREL", :Address ],
+             24 => [ :BindNow, "BINDNOW", :Ignore ],
+             25 => [ :InitArray, "INIT_ARRAY", :Address ],
+             26 => [ :FiniArray, "FINI_ARRAY", :Address ],
+             27 => [ :InitArraySz, "INIT_ARRAYSZ", :Value ],
+             28 => [ :FiniArraySz, "FINI_ARRAYSZ", :Value ],
+             29 => [ :RunPath, "RUNPATH", :Value ],
+             30 => [ :Flags, "FLAGS", :Value ],
+             32 => [ :PreinitArray, "PREINIT_ARRAY", :Address ],
+             33 => [ :PreinitArraySz, "PREINIT_ARRAYSZ", :Value ],
+
+             # DT_VAL* constants mapping
+             0x6ffffdf5 => [ :GNUPrelinked, "GNU_PRELINKED", :Value ],
+             0x6ffffdf6 => [ :GNUConflictSz, "GNU_CONFLICTSZ", :Value ],
+             0x6ffffdf7 => [ :GNULibListSz, "GNU_LIBLISTSZ", :Value ],
+             0x6ffffdf8 => [ :CheckSum, "CHECKSUM", :Value ],
+             0x6ffffdf9 => [ :PltPadSz, "PLTPADSZ", :Value ],
+             0x6ffffdfa => [ :MoveEnt, "MOVENT", :Value ],
+             0x6ffffdfb => [ :MoveSz, "MOVESZ", :Value ],
+             0x6ffffdfc => [ :Feature1, "FEATURE_1", :Value ],
+             0x6ffffdfd => [ :PosFlag1, "POSFLAG_1", :Value ],
+             0x6ffffdfe => [ :SymInSz, "SYMINSZ", :Value ],
+             0x6ffffdff => [ :SymInEnt, "SYMINENT", :Value ],
+
+             # DT_ADDR* constants mapping
+             0x6ffffef5 => [ :GNUHash, "GNU_HASH", :Address ],
+             0x6ffffef6 => [ :TLSDescPlt, "TLSDESC_PLT", :Address ],
+             0x6ffffef7 => [ :TLSDescGot, "TLSDESC_GOT", :Address ],
+             0x6ffffef8 => [ :GNUConflict, "GNU_CONFLICT", :Address ],
+             0x6ffffef9 => [ :GNULibList, "GNU_LIBLIST", :Address ],
+             0x6ffffefa => [ :Config, "CONFIG", :Address ],
+             0x6ffffefb => [ :DepAudit, "DEPAUDIT", :Address ],
+             0x6ffffefc => [ :PltPad, "PLTPAD", :Address ],
+             0x6ffffefd => [ :MoveTab, "MOVETAB", :Address ],
+             0x6ffffeff => [ :SymInfo, "SYMINFO", :Address ],
+
+             # GNU extension, should be named :GNUVerSym?
+             0x6ffffff0 => [ :VerSym, "VERSYM", :Ignore ],
+
+             0x6ffffff9 => [ :RelACount, "RELACOUNT", :Value ],
+             0x6ffffffa => [ :RelCount, "RELCOUNT", :Value ],
+
+             # Sun extensions, should be named :Sun*?
+             0x6ffffffb => [ :Flags1, "FLAGS_1", :Value ],
+             0x6ffffffc => [ :VerDef, "VERDEF", :Address ],
+             0x6ffffffd => [ :VerDefNum, "VERDEFNUM", :Value ],
+             0x6ffffffe => [ :VerNeed, "VERNEED", :Address ],
+             0x6fffffff => [ :VerNeedNum, "VERNEEDNUM", :Value ],
+
+             # Unknown CPU-specific extensions
+             0x7ffffffd => [ :Auxiliary, "AUXILIARY", :Value ]
+           )
+
+      OsSpecific = 0x60000000..0x6fffffff
+      ProcSpecific = 0x70000000..0x7fffffff
+      SpecialRanges = {
+        "DT_LOOS" => OsSpecific,
+        "DT_LOPROC" => ProcSpecific
+      }
+    end
+
+    module Flags
+      Origin     = 0x00000001
+      Symbolic   = 0x00000002
+      Textrel    = 0x00000004
+      BindNow    = 0x00000008
+      StaticTLS  = 0x00000010
+    end
+
+    module Flags1
+      Now        = 0x00000001
+      Global     = 0x00000002
+      Group      = 0x00000004
+      NoDelete   = 0x00000008
+      LoadFltr   = 0x00000010
+      InitFirst  = 0x00000020
+      NoOpen     = 0x00000040
+      Origin     = 0x00000080
+      Direct     = 0x00000100
+      Trans      = 0x00000200
+      Interpose  = 0x00000400
+      NoDefLib   = 0x00000800
+      NoDump     = 0x00001000
+      ConfAlt    = 0x00002000
+      EndFiltee  = 0x00004000
+      DispRelDNE = 0x00008000
+      DispRelPND = 0x00010000
+    end
+
+    module Features1
+      ParInit    = 0x00000001
+      ConfExp    = 0x00000002
+    end
+
+    module PosFlags1
+      LazyLoad   = 0x00000001
+      GroupPerm  = 0x00000002
+    end
+
+    # A .dynamic section entry
+    class Entry
+      attr_reader :type, :value
+
+      def initialize(type, file)
+        @file = file
+        @type = type
+        @value = case type.attribute
+                 when :Address then @file.read_addr
+                 when :Value then @file.elf_class == Class::Elf32 ? @file.read_word : @file.read_xword
+                 else @file.read_addr
+                 end
+      end
+    end
+
+    # An entry for a string value
+    class StringEntry < Entry
+      def parsed
+        @parsed = @file['.dynstr'][@value] unless @parsed
+        return @parsed
+      end
+    end
+
+    # An entry for a timestamp value
+    class TimestampEntry < Entry
+      def parsed
+        @parsed = Time.at(@value) unless @parsed
+        return @parsed
+      end
+    end
+
+    # An entry for the address of another section
+    class SectionLink < Entry
+      def parsed
+        @parsed = @file.find_section_by_addr(@value) unless @parsed
+        return @parsed
+      end
+    end
+
+    ClassMap = {
+      Type::Needed       => StringEntry,
+      Type::Hash         => SectionLink,
+      Type::StrTab       => SectionLink,
+      Type::SymTab       => SectionLink,
+      Type::Init         => SectionLink,
+      Type::Fini         => SectionLink,
+      Type::SoName       => StringEntry,
+      Type::RPath        => StringEntry,
+      Type::RunPath      => StringEntry,
+      Type::GNUPrelinked => TimestampEntry,
+      Type::GNUHash      => SectionLink,
+      Type::Auxiliary    => StringEntry
+    }
+
+    def load_internal
+      elf32 = @file.elf_class == Class::Elf32
+
+      @entries = []
+
+      for i in 1..@numentries
+        type = Type[elf32 ? @file.read_sword : @file.read_sxword]
+
+        @entries << if ClassMap.has_key? type
+                      ClassMap[type].new(type, @file)
+                    else
+                      Entry.new(type, @file)
+                    end
+
+        break if type == Type::Null
+      end
+    end
+
+    # Iterate over all the entries in the .dynamic section.
+    def each_entry(&block)
+      load unless @entries
+
+      @entries.each(&block)
+    end
+
+    # Return the amount of entries in the .dynamic section.
+    def count
+      load unless @entries
+
+      @entries.size
+    end
+
+    def soname
+      each_entry do |entry|
+        return entry.parsed if entry.type == Type::SoName
+      end
+
+      return nil
+    end
+
+    # Returns the value of DT_RPATH entries in the file
+    def rpath
+      @rpath ||= auxiliary_library_path(Type::RPath)
+    end
+
+    # Returns the value of DT_RUNPATH entries in the file
+    def runpath
+      @runpath ||= auxiliary_library_path(Type::RunPath)
+    end
+
+    # Returns the auxiliary path specified by the given type
+    #
+    # Please never use this function because it does not caches its
+    # values, use Dynamic#rpath or Dynamic#runpath instead.
+    def auxiliary_library_path(type)
+      retval = Array.new
+
+      each_entry do |entry|
+        next unless entry.type == type
+        retval.concat entry.parsed.split(":")
+      end
+
+      return retval.uniq.collect do |path|
+        if path == "$ORIGIN" or path == "${ORIGIN}"
+          Pathname.new(@file.path).dirname
+        else
+          begin
+            Pathname.new(path).realpath
+          rescue Errno::ENOENT
+            path
+          end
+        end.to_s
+      end
+    end
+
+    # Returns the complete library path for the current ELF file.
+    #
+    # Since the ELF loaders have somewhat complex rules to identify
+    # the path to load dependencies from, we evalute it on a per-file
+    # basis.
+    def complete_library_path
+      if @complete_library_path.nil?
+        @complete_library_path = Array.new
+
+        # If there is no DT_RUNPATH. RPATH wins over the LD_LIBRARY_PATH
+        @complete_library_path.concat rpath unless runpath.empty?
+
+        @complete_library_path.concat Elf::Utilities.environment_library_path
+
+        # If there is a DT_RUNPATH it wins over the system library path
+        @complete_library_path.concat runpath
+
+        @complete_library_path.concat Elf::Utilities.system_library_path
+
+        @complete_library_path.uniq!
+      end
+
+      return @complete_library_path
+    end
+
+    # Return the ELF library corresponding to the given soname.
+    #
+    # This function gets the system library paths and eventually adds
+    # the rpaths as expressed by the file itself, then look them up to
+    # find the proper library, just like the loader would.
+    def find_library(soname)
+      complete_library_path.each do |path|
+        # For the ELF linker an empty entry in the library path is the
+        # same as "." and means the current working directory, so
+        # replace it.
+        path = "." if path == ""
+
+        if FileTest.exist? "#{path}/#{soname}"
+          begin
+            possible_library = Elf::Utilities::FilePool["#{path}/#{soname}"]
+
+            return possible_library if @file.is_compatible(possible_library)
+          rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR, Elf::File::NotAnELF
+            # we don't care if the file does not exist and similar.
+          end
+        end
+      end
+
+      return nil
+    end
+
+    # Returns an array of needed sonames from .dynamic section
+    #
+    # This function reads the .dynamic section of the file for
+    # DT_NEEDED entries, and fills an array with them.
+    def needed_sonames
+      if @needed_sonames.nil?
+        @needed_sonames = Array.new
+
+        each_entry do |entry|
+          next unless entry.type == Elf::Dynamic::Type::Needed
+
+          @needed_sonames << entry.parsed
+        end
+      end
+
+      return @needed_sonames
+    end
+
+    # Returns an hash representing the dependencies of the ELF file.
+    #
+    # This function reads the .dynamic section of the file for
+    # DT_NEEDED entries, then looks for them and add them to an hash.
+    #
+    # Note that nil values in the hash means that the library couldn't
+    # be found on either the runpath of the file or the system library
+    # path.
+    def needed_libraries
+      # Make sure to cache the thing, we don't want to have to parse
+      # this multiple times since we might access it over and over to
+      # check the dependencies.
+      if @needed_libraries.nil?
+        @needed_libraries = Hash.new
+
+        needed_sonames.each do |soname|
+          @needed_libraries[soname] = find_library(soname)
+        end
+      end
+
+      return @needed_libraries
+    end
+  end
+end

data/lib/elf/file.rb

@@ -0,0 +1,407 @@
+# -*- coding: utf-8 -*-
+# Simple ELF parser for Ruby
+#
+# Copyright © 2007-2010 Diego Elio Pettenò <flameeyes@flameeyes.eu>
+# Portions inspired by elf.py
+#   Copyright © 2002 Netgraft Corporation
+# Portions inspired by elf.h
+#   Copyright © 1995-2006 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this generator; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'bytestream-reader'
+require 'pathname'
+
+module Elf
+  class File < ::File
+    include BytestreamReader
+
+    class NotAnELF < Exception
+      def initialize
+        super("not a valid ELF file")
+      end
+    end
+
+    class InvalidElfClass < Exception
+      def initialize(klass)
+        super("Invalid Elf Class #{klass}")
+      end
+    end
+
+    class InvalidDataEncoding < Exception
+      def initialize(encoding)
+        super("Invalid Elf Data Encoding #{encoding}")
+      end
+    end
+
+    class UnsupportedElfVersion < Exception
+      def initialize(version)
+        super("Unsupported Elf version #{version}")
+      end
+    end
+
+    class InvalidOsAbi < Exception
+      def initialize(abi)
+        super("Invalid Elf ABI #{abi}")
+      end
+    end
+
+    class InvalidElfType < Exception
+      def initialize(type)
+        super("Invalid Elf type #{type}")
+      end
+    end
+
+    class InvalidMachine < Exception
+      def initialize(machine)
+        super("Invalid Elf machine #{machine}")
+      end
+    end
+
+    class Type < Value
+      fill(
+             0 => [ :None, 'No file type' ],
+             1 => [ :Rel, 'Relocatable file' ],
+             2 => [ :Exec, 'Executable file' ],
+             3 => [ :Dyn, 'Shared object file' ],
+             4 => [ :Core, 'Core file' ]
+           )
+
+      OsSpecific = 0xfe00..0xfeff
+      ProcSpecific = 0xff00..0xffff
+    end
+
+    attr_reader :elf_class, :data_encoding, :type, :version, :abi,
+                :abi_version, :machine, :entry_address, :phoff, :shoff,
+                :flags, :ehsize, :phentsize, :phnum, :shentsize, :shnum,
+                :shstrndx
+    attr_reader :string_table
+
+    # raw data access
+    attr_reader :shoff
+
+    def read_addr
+      case @elf_class
+      when Class::Elf32 then read_u32
+      when Class::Elf64 then read_u64
+      end
+    end
+
+    def read_off
+      case @elf_class
+      when Class::Elf32 then read_u32
+      when Class::Elf64 then read_u64
+      end
+    end
+
+    alias :read_half :read_u16
+
+    alias :read_word :read_u32
+    alias :read_sword :read_s32
+
+    alias :read_xword :read_u64
+    alias :read_sxword :read_s64
+
+    alias :read_section :read_u16
+    alias :read_versym :read_half
+
+    def _checkvalidpath(path)
+      # We're going to check the path we're given for a few reasons,
+      # the first of which is that we do not want to open a pipe or
+      # something like that. If we were just to leave it to File.open,
+      # we would end up stuck waiting for data on a named pipe, for
+      # instance.
+      #
+      # We cannot just use File.file? either because it'll be ignoring
+      # ENOENT by default (which would be bad for us).
+      #
+      # If we were just to use File.ftype we would have to handle
+      # manually the links... since Pathname will properly report
+      # ENOENT for broken links, we're going to keep it this way.
+      path = Pathname.new(path) unless path.is_a? Pathname
+
+      case path.ftype
+      when "directory" then raise Errno::EISDIR
+      when "file" then # do nothing
+      when "link"
+        # we use path.realpath here; the reason is that if
+        # we're to use readlink we're going to have a lot of
+        # trouble to find the correct path. We cannot just
+        # always use realpath as that will run too many stat
+        # calls and have a huge hit on performance.
+        _checkvalidpath(path.realpath)
+      else
+        raise Errno::EINVAL
+      end
+    end
+
+    private :_checkvalidpath
+
+    def initialize(path)
+      _checkvalidpath(path)
+
+      super(path, "rb")
+
+      begin
+        begin
+          raise NotAnELF unless readexactly(4) == MagicString
+        rescue EOFError
+          raise NotAnELF
+        end
+
+        begin
+          @elf_class = Class[read_u8]
+        rescue Value::OutOfBound => e
+          raise InvalidElfClass.new(e.val)
+        end
+
+        begin
+          @data_encoding = DataEncoding[read_u8]
+        rescue Value::OutOfBound => e
+          raise InvalidDataEncoding.new(e.val)
+        end
+
+        @version = read_u8
+        raise UnsupportedElfVersion.new(@version) if @version > 1
+
+        begin
+          @abi = OsAbi[read_u8]
+        rescue Value::OutOfBound => e
+          raise InvalidOsAbi.new(e.val)
+        end
+        @abi_version = read_u8
+
+        seek(16, IO::SEEK_SET)
+        set_endian(DataEncoding::BytestreamMapping[@data_encoding])
+
+        begin
+          @type = Type[read_half]
+        rescue Value::OutOfBound => e
+          raise InvalidElfType.new(e.val)
+        end
+        
+        begin
+          @machine = Machine[read_half]
+        rescue Value::OutOfBound => e
+          raise InvalidMachine.new(e.val)
+        end
+
+        @version = read_word
+        @entry_address = read_addr
+        @phoff = read_off
+        @shoff = read_off
+        @flags = read_word
+        @ehsize = read_half
+        @phentsize = read_half
+        @phnum = read_half
+        @shentsize = read_half
+        @shnum = read_half
+        @shstrndx = read_half
+
+        elf32 = elf_class == Class::Elf32
+        @sections = {}
+
+        @sections_data = []
+        seek(@shoff)
+        for i in 1..@shnum
+          sectdata = {}
+          sectdata[:idx]       = i-1
+          sectdata[:name_idx]  = read_word
+          sectdata[:type_id]   = read_word
+          sectdata[:flags_val] = elf32 ? read_word : read_xword
+          sectdata[:addr]      = read_addr
+          sectdata[:offset]    = read_off
+          sectdata[:size]      = elf32 ? read_word : read_xword
+          sectdata[:link]      = read_word
+          sectdata[:info]      = read_word
+          sectdata[:addralign] = elf32 ? read_word : read_xword
+          sectdata[:entsize]   = elf32 ? read_word : read_xword
+
+          @sections_data << sectdata
+        end
+
+        # When the section header string table index is set to zero,
+        # there is not going to be a string table in the file, this
+        # happens usually when the file is a static ELF file built
+        # directly with an assembler, or when it was passed through
+        # the elfkickers' sstrip utility.
+        #
+        # To handle this specific case, set the @string_table attribute
+        # to false, that is distinct from nil, and raise
+        # MissingStringTable on request. If the string table is not yet
+        # loaded raise instead StringTableNotLoaded.
+        if @shstrndx == 0 or not self[@shstrndx].is_a? StringTable
+          @string_table = false
+        else
+          @string_table = self[@shstrndx]
+
+          @sections_names = {}
+          @sections_data.each do |sectdata|
+            @sections_names[@string_table[sectdata[:name_idx]]] = sectdata[:idx]
+          end
+        end
+      rescue ::Exception => e
+        close
+        raise e
+      end
+    end
+
+    class MissingSection < Exception
+      def initialize(sect_identifier)
+        super("Requested section #{sect_identifier} not found in the file")
+      end
+    end
+
+    def load_section(sect_idx_or_name)
+      if sect_idx_or_name.is_a? Integer
+        raise MissingSection.new(sect_idx_or_name) unless
+          @sections_data[sect_idx_or_name]
+
+        @sections[sect_idx_or_name] = Section.read(self, sect_idx_or_name, @sections_data[sect_idx_or_name])
+      else
+        raise MissingSection.new(sect_idx_or_name) unless
+          @sections_names[sect_idx_or_name]
+        
+        load_section @sections_names[sect_idx_or_name]
+
+        @sections[sect_idx_or_name] = @sections[@sections_names[sect_idx_or_name]]
+      end
+    end
+
+    class StringTableNotLoaded < Exception
+      def initialize(sect_name)
+        super("Requested section '#{sect_name}' but there is no string table yet.")
+      end
+    end
+
+    class MissingStringTable < Exception
+      def initialize(sect_name)
+        super("Requested section '#{sect_name}' but the file has no string table.")
+      end
+    end
+
+    def sections
+      return @sections_data.size
+    end
+
+    def [](sect_idx_or_name)
+      if sect_idx_or_name.is_a? String and not @string_table.is_a? Elf::Section
+        raise MissingStringTable.new(sect_idx_or_name) if @string_table == false
+        raise StringTableNotLoaded.new(sect_idx_or_name) if @string_table.nil?
+      end
+
+      load_section(sect_idx_or_name) unless
+        @sections.has_key? sect_idx_or_name
+
+      return @sections[sect_idx_or_name]
+    end
+
+    def each_section
+      @sections_data.each do |sectdata|
+        load_section(sectdata[:idx])
+        yield @sections[sectdata[:idx]]
+      end
+    end
+
+    def find_section_by_addr(addr)
+      @sections_data.each do |sectdata|
+        next unless sectdata[:addr] == addr
+        load_section(sectdata[:idx])
+        return @sections[sectdata[:idx]]
+      end
+    end
+
+    def has_section?(sect_idx_or_name)
+
+      if sect_idx_or_name.is_a? String and not @string_table.is_a? Elf::Section
+        raise MissingStringTable.new(sect_idx_or_name) if @string_table == false
+        raise StringTableNotLoaded.new(sect_idx_or_name) if @string_table.nil?
+      end
+
+      if sect_idx_or_name.is_a? Integer
+        return @sections_data[sect_idx_or_name] != nil
+      elsif sect_idx_or_name.is_a? String
+        return @sections_names.has_key?(sect_idx_or_name)
+      else
+        raise TypeError.new("wrong argument type #{sect_idx_or_name.class} (expected String or Integer)")
+      end
+    end
+
+    # Returns the hex address size for the file.
+    #
+    # Since each ELF file uses either 32- or 64-bit addresses, it is
+    # important to know how many characters a file's address would
+    # require when printed as an hexadecimal string.
+    def address_print_size
+      (@elf_class == Elf::Class::Elf32 ? 8 : 16)
+    end
+
+    def summary
+      $stdout.puts "ELF file #{path}"
+      $stdout.puts "ELF class: #{@elf_class} #{@data_encoding} ver. #{@version}"
+      $stdout.puts "ELF ABI: #{@abi} ver. #{@abi_version}"
+      $stdout.puts "ELF type: #{@type} machine: #{@machine}"
+      $stdout.puts "Sections:"
+      @sections.values.uniq.each do |sh|
+        sh.summary
+      end
+
+      return nil
+    end
+
+    # Checks whether two ELF files are compatible one with the other for linking
+    #
+    # This function has to check whether two ELF files can be linked
+    # together (either at build time or at load time), and thus checks
+    # for class, encoding, versioning, ABI and machine type.
+    #
+    # Note that it explicitly does not check for ELF file type since
+    # you can link different type of files together, like an
+    # Executable with a Dynamic library.
+    def is_compatible(other)
+      raise TypeError.new("wrong argument type #{other.class} (expected Elf::File)") unless
+        other.is_a? Elf::File
+
+      compatible_abi = (@abi.linux_compatible? && other.abi.linux_compatible?) \
+        || ([@abi, @abi_version] == [other.abi, other.abi_version])
+
+      @elf_class == other.elf_class and
+        @data_encoding == other.data_encoding and
+        @version == other.version and
+        @machine == other.machine and
+        compatible_abi
+    end
+
+    # Constants used for ARM-architecture files, as described by the
+    # official documentation, "ELF for the ARM® Architecture", 28
+    # October 2009.
+    module ARM
+      EFlags_EABI_Mask = 0xFF000000
+      EFlags_BE8       = 0x00800000
+    end
+
+    def arm_eabi_version
+      return nil if machine != Elf::Machine::ARM
+
+      return (@flags & ARM::EFlags_EABI_Mask) >> 24
+    end
+
+    def arm_be8?
+      return nil if machine != Elf::Machine::ARM
+
+      return (@flags & ARM::EFlags_BE8) == ARM::EFlags_BE8
+    end
+  end
+end