ony-ruby-elf 1.1.0

data/lib/elf/stringtable.rb

@@ -0,0 +1,39 @@
+# -*- 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/section'
+require 'elf/utils/offsettable'
+
+module Elf
+  class StringTable < Section
+    def load_internal
+      @rawtable = Utilities::OffsetTable.new(@file.readexactly(@size), "\x00")
+    end
+
+    def [](idx)
+      load unless @rawtable
+
+      @rawtable[idx]
+    end
+  end
+end

data/lib/elf/sunw.rb

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+# Simple ELF parser for Ruby
+#
+# Copyright © 2008-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.
+# Constants derived from OpenSolaris elf.h and documentation
+#   Copyright © 2007 Sun Microsystems, 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
+
+module Elf
+  # Sun-specific sections parsing
+  module SunW
+
+    class Capabilities < Section
+      class Tag < Value
+        fill(
+             0 => [ :Null, nil ],
+             1 => [ :HW1, "Hardware capabilities" ],
+             2 => [ :SF1, "Software capabilities" ]
+             )
+      end
+
+      class Software1 < Value
+        fill(
+             0x0001 => [ :FramePointerKnown, "Frame pointer use is known" ],
+             0x0002 => [ :FramePointerUsed, "Frame pointer is used" ]
+             )
+
+        # Known capabilities mask
+        KnownMask         = 0x003
+      end
+
+      module Hardware1
+        class Sparc < Value
+          fill(
+               0x0001 => [ :Mul32, "Uses 32x32-bit smul/umul" ],
+               0x0002 => [ :Div32, "Uses 32x32-bit sdiv/udiv" ],
+               0x0004 => [ :Fsmuld, "Uses fsmuld instruction" ],
+               0x0008 => [ :V8Plus, "Uses V9 intructins in 32-bit apps" ],
+               0x0010 => [ :Popc, "Uses popc instruction" ],
+               0x0020 => [ :Vis, "Uses VIS instruction set" ],
+               0x0040 => [ :Vis2, "Uses VIS2 instruction set" ],
+               0x0080 => [ :AsiBlkInit, nil ],
+               0x0100 => [ :Fmaf, "Uses Fused Multiply-Add" ],
+               0x0200 => [ :FjFmau, "Uses Fujitsu Unfused Multiply-Add" ],
+               0x0400 => [ :Ima, "Uses Integer Multiply-Add" ]
+               )
+        end
+
+        class I386 < Value
+          fill(
+               0x00000001 => [ :FPU, "Uses x87-style floating point" ],
+               0x00000002 => [ :TSC, "Uses rdtsc instruction" ],
+               0x00000004 => [ :CX8, "Uses cmpxchg8b instruction" ],
+               0x00000008 => [ :SEP, "Uses sysenter/sysexit instructions" ],
+               0x00000010 => [ :AmdSycC, "Uses AMD's syscall/sysret instructions" ],
+               0x00000020 => [ :CMov, "Uses conditional move instructions" ],
+               0x00000040 => [ :MMX, "Uses MMX instruction set" ],
+               0x00000080 => [ :AmdMMX, "Uses AMD's MMX instruction set" ],
+               0x00000100 => [ :Amd3DNow, "Uses AMD's 3DNow! instruction set" ],
+               0x00000200 => [ :Amd3DNowX, "Uses AMD's 3DNow! extended instruction set" ],
+               0x00000400 => [ :FXSR, "Uses fxsave/fxrstor instructions" ],
+               0x00000800 => [ :SSE, "Uses SSE instruction set and registers" ],
+               0x00001000 => [ :SSE2, "Uses SSE2 instruction set and registers" ],
+               0x00002000 => [ :Pause, "Uses pause instruction" ],
+               0x00004000 => [ :SSE3, "Uses SSE3 instruction set and registers" ],
+               0x00008000 => [ :Mon, "Uses monitor/mwait instructions" ],
+               0x00010000 => [ :CX16, "Uses cmpxchg16b instruction" ],
+               0x00020000 => [ :AHF, "Uses lahf/sahf instructions" ],
+               0x00040000 => [ :TSCP, "Uses rdtscp instruction" ],
+               0x00080000 => [ :AmdSSE4a, "Uses AMD's SSEA4a instructions" ],
+               0x00100000 => [ :PopCnt, "Uses popcnt instruction" ],
+               0x00200000 => [ :AmdLzcnt, "Uses AMD's lzcnt instructon" ],
+               0x00400000 => [ :SSSE3, "Uses Intel's SSSE3 instruction set" ],
+               0x00800000 => [ :SSE4_1, "Uses Intel's SSE4.1 instruction set" ],
+               0x01000000 => [ :SSE4_2, "uses Intel's SSE4.2 instruction set" ]
+               )
+        end
+      end
+
+      def load_internal
+        elf32 = @file.elf_class == Class::Elf32
+
+        @entries = []
+        loop do
+          entry = {}
+          tag = elf32 ? @file.read_word : @file.read_xword
+          entry[:tag] = Tag[tag]
+
+          # This marks the end of the array.
+          break if entry[:tag] == Tag::Null
+
+          # Right now the only two types used make only use of c_val,
+          # but in the future there might be capabilities using c_ptr,
+          # so prepare for that.
+          case entry[:tag]
+          when Tag::SF1
+            val = elf32 ? @file.read_word : @file.read_xword
+            entry[:flags] = Set.new
+            
+            Software1.each do |flag|
+              entry[:flags].add(flag) if (val & flag.val) == flag.val
+            end
+          when Tag::HW1
+            val = elf32 ? @file.read_word : @file.read_xword
+            entry[:flags] = Set.new
+
+            case @file.machine
+            when Machine::Sparc
+              Hardware1::Sparc.each do |flag|
+                entry[:flags].add(flag) if (val & flag.val) == flag.val
+              end
+            when Machine::I386
+              Hardware1::I386.each do |flag|
+                entry[:flags].add(flag) if (val & flag.val) == flag.val
+              end
+            else
+              raise "Sun-specific extensions only support i386/Sparc!"
+            end
+                
+          else
+            entry[:ptr] = @file.read_addr
+          end
+
+          @entries << entry
+        end
+      end
+      
+      def size
+        load unless @entries
+        
+        @entries.size
+      end
+
+      def [](idx)
+        load unless @entries
+        
+        @entries[idx]
+      end
+    end
+  end
+end

data/lib/elf/symbol.rb

@@ -0,0 +1,406 @@
+# -*- 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
+
+module Elf
+  class Symbol
+    class Binding < Value
+      fill(
+           0 => [ :Local, 'Local symbol' ],
+           1 => [ :Global, 'Global symbol' ],
+           2 => [ :Weak, 'Weak symbol' ],
+           # This one is inferred out of libpam.so
+           3 => [ :Number, 'Number of defined type' ]
+           )
+
+      class GNU < Value
+        fill(
+             10 => [ :Unique, 'Unique symbol' ]
+             )
+      end
+
+      OsSpecific = 10..12
+      ProcSpecific = 13..15
+
+      SpecialRanges = {
+        "STB_LOOS" => OsSpecific,
+        "STB_LOPROC" => ProcSpecific
+      }
+    end
+
+    class Type < Value
+      fill(
+           0 => [ :None, 'Unspecified' ],
+           1 => [ :Object, 'Data object' ],
+           2 => [ :Func, 'Code object' ],
+           3 => [ :Section, 'Associated with a section' ],
+           4 => [ :File, 'File name' ],
+           5 => [ :Common, 'Common data object' ],
+           6 => [ :TLS, 'Thread-local data object' ]
+           )
+
+      class GNU < Value
+        fill(
+             10 => [ :IFunc, 'Indirect function' ]
+             )
+      end
+
+      OsSpecific = 10..12
+      ProcSpecific = 13..15
+      SpecialRanges = {
+        "STT_LOOS" => OsSpecific,
+        "STT_LOPROC" => ProcSpecific
+      }
+    end
+
+    class Visibility < Value
+      fill(
+           0 => [ :Default, 'Default visibility' ],
+           1 => [ :Internal, 'Processor-specific hidden visibility' ],
+           2 => [ :Hidden, 'Hidden visibility' ],
+           3 => [ :Protected, 'Protected visibility' ],
+           4 => [ :Exported, 'Exported symbol' ],
+           5 => [ :Singleton, 'Singleton symbol' ],
+           6 => [ :Eliminate, 'Symbol to be eliminated' ]
+           )
+    end
+
+    attr_reader :value, :size, :other, :bind, :type, :idx, :visibility, :file
+
+    # Create a new Symbol object reading the symbol structure from the file.
+    # This function assumes that the elf file is aligned ad the
+    # start of a symbol structure, and returns the file moved at the
+    # start of the symbol.
+    def initialize(elf, symsect, idx)
+      @symsect = symsect
+      @idx = idx
+
+      case elf.elf_class
+      when Class::Elf32
+        @name = elf.read_word
+        @value = elf.read_addr
+        @size = elf.read_word
+        info = elf.read_u8
+        @other = elf.read_u8
+        @section = elf.read_section
+      when Class::Elf64
+        @name = elf.read_word
+        info = elf.read_u8
+        @other = elf.read_u8
+        @section = elf.read_section
+        @value = elf.read_addr
+        @size = elf.read_xword
+      end
+
+      begin
+        type_value = info & 0xF
+        @type = case
+                when Type::OsSpecific.include?(type_value)
+                  # Assume always GNU for now, but it's wrong
+                  Type::GNU[type_value]
+                else
+                  Type[type_value]
+                end
+
+        binding_value = info >> 4
+        @bind = case
+                when Binding::OsSpecific.include?(binding_value)
+                  # Assume always GNU for now, but it's wrong
+                  Binding::GNU[binding_value]
+                else
+                  Binding[binding_value]
+                end
+
+      rescue Elf::Value::OutOfBound => e
+        e.append_message(sprintf("While processing symbol %d. Symbol 'info' value: 0x%x",
+                                 @idx,
+                                 info))
+        raise e
+      end
+
+      begin
+        @visibility = Visibility[@other & 0x03]
+      rescue Elf::Value::OutOfBound => e
+        e.append_message(sprintf("While procesing symbol %d. Symbol 'other' value: 0x%x",
+                                 @idx,
+                                 other))
+        raise e
+      end
+
+      @file = elf
+    end
+    
+    class InvalidName < Exception
+      def initialize(name_idx, sym, symsect)
+        super("Invalid name index in #{symsect.link.name} #{name_idx} for symbol #{sym.idx}")
+      end
+    end
+
+    def name
+      # We didn't read the name in form of string yet;
+      if @name.is_a? Integer and @symsect.link
+        begin
+          name = @symsect.link[@name]
+        rescue Utilities::OffsetTable::InvalidIndex
+          raise InvalidName.new(@name, self, @symsect)
+        end
+        @name = name if name
+      end
+
+      @name
+    end
+
+    # Alias to_s to name so that using this in a string will report the name
+    alias :to_s :name
+
+    def section
+      # We didn't read the section yet.
+      @section = nil if @section.is_a? Integer and @section == 0
+      
+      if @section.is_a? Integer and
+          not Section::Reserved.include?(@section) and
+          @file.has_section?(@section)
+
+        @section = @file[@section]
+      end
+
+      @section
+    end
+
+    def version
+      # bit 15 is meant to say that this symbol is _not_ the default
+      # version to link to; we don't care about that here so we simply
+      # ignore its presence.
+      version_idx = version_index & ~(1 << 15)
+
+      return nil unless version_idx && version_idx >= 1
+
+      return '' if version_idx == 1
+
+      begin
+        if section.nil?
+          return @file['.gnu.version_r'][version_idx][:name]
+        else
+          return @file['.gnu.version_d'][version_idx][:names][0]
+        end
+      rescue Elf::File::MissingSection
+        return @file['.gnu.version_r'][version_idx][:name]
+      end
+    end
+
+    # the default symbol version is the one that the link editor will
+    # use when linking against the library; any symbol is the default
+    # symbol unless bit 15 of its version index is set.
+    #
+    # An undefined symbol cannot be the default symbol
+    def version_default?
+      !section.nil? and (version_index & (1 << 15) == 0)
+    end
+
+    def defined?
+      return false if section.nil?
+      return false if section.is_a?(Integer)
+      return false if bind == Binding::Weak and value == 0
+      return true
+    end
+
+    # Exception raised when the NM code for a given symbol is unknown.
+    class UnknownNMCode < Exception
+      def initialize(symbol)
+        section = if symbol.section.nil?
+                    nil
+                  elsif symbol.section.is_a?(Integer)
+                    sprintf("%x", symbol.section)
+                  else
+                    symbol.section.name
+                  end
+
+        super("Unknown NM code for symbol #{symbol.name} in section #{section}")
+      end
+    end
+
+    # Show the letter code as compatible with GNU nm
+    #
+    # This function has been moved inside the library since multiple
+    # tools based on ruby-elf would be using these code to report
+    # symbols, and since the code is complex it's easier to have it
+    # here.
+    #
+    # The resturned value is a one-letter string. The function may
+    # raise an UnknownNMCode exception.
+    def nm_code
+      @nmflag ||= nm_code_internal
+    end
+
+    # Convenience function for the first tile the nm code is requested.
+    def nm_code_internal
+      nmflag = nil
+
+      case
+      when idx == 0
+        return " "
+
+        # When the section is nil, it means it goes into the Undef
+        # section, and the symbol is not defined.
+      when section.nil?
+        nmflag = "U"
+
+      when bind == Binding::Weak
+        nmflag = case type
+                 when Type::Object then 'V'
+                   # we cannot use 'v' when value is zero, as for a
+                   # variable, a zero address is correct, it's just
+                   # functions that cannot be at zero address.
+                 when value == 0 then 'w'
+                 else 'W'
+                 end
+
+      when bind == Binding::GNU::Unique
+        nmflag = 'u'
+
+      when section == Elf::Section::Abs
+        nmflag = "A"
+      when type == Type::Common, section == Elf::Section::Common
+        # section check _should_ be limited to objects with
+        # Type::Data, but turns out that ICC does not emit
+        # uninitialised variables correctly, creating a Type::None
+        # object defined in Section::Common. Handle that properly.
+        nmflag = 'C'
+
+      when type == Type::Object, type == Type::TLS
+        # data object, distinguish between writable or read-only data,
+        # as well as data in Section::Type::NoBits sections.
+        nmflag = case
+                 when section.is_a?(Integer) then nil
+                 when !section.flags.include?(Elf::Section::Flags::Write) then "R"
+                 when section.type == Elf::Section::Type::NoBits then "B"
+                 else "D"
+                 end
+
+      when type == Type::None
+        # try being smarter than simply reporthing this as a none-type
+        # symbol, as some compilers (namely pathCC) emit STT_NONE
+        # symbols that are instead functions.
+        nmflag = case
+                 when section.is_a?(Integer) then "N"
+                 when section.flags.include?(Elf::Section::Flags::ExecInstr) then "T"
+                 when section.type == Elf::Section::Type::NoBits then "B"
+                 else "N"
+                 end
+      when type == Type::Func
+        nmflag = 'T'
+      when type == Type::Section
+        nmflag = 'S'
+      when type == Type::File
+        nmflag = 'F'
+      when type == Type::GNU::IFunc
+        nmflag = 'i'
+      end
+
+      # If we haven't found the flag with the above code, we don't
+      # know what to use, so raise exception.
+      raise UnknownNMCode.new(self) if nmflag.nil?
+
+      nmflag = nmflag.dup
+
+      nmflag.downcase! if bind == Binding::Local
+
+      return nmflag
+    end
+
+    # Reports the symbol's address as a string, if any is provided
+    #
+    # Reports a string full of whitespace if the symbols is not
+    # defined (as there is no address)
+    def address_string
+      section ? sprintf("%0#{@file.address_print_size}x", value) : ''
+    end
+
+    # Check whether two symbols are the same
+    #
+    # This function compares the name, version and section of two
+    # symbols to tell if they are the same symbol.
+    def ==(other)
+      return false unless other.is_a? Symbol
+
+      return false unless name == other.name
+      return false unless version == other.version
+
+      return false if section == nil and other.section != nil
+      return false if section != nil and other.section == nil
+
+      return true
+    end
+
+    def eql?(other)
+      return self == other
+    end
+
+    # Check whether one symbol is compatible with the other
+    #
+    # This function compares the name and version of two symbols, and
+    # ensures that only one of them is undefined; this allows to
+    # establish whether one symbol might be satisfied by another.
+    def =~(other)
+      return false unless other.is_a? Symbol
+
+      return false unless name == other.name
+      return false unless version == other.version
+
+      return false if section == nil and other.section == nil
+      return false if section != nil and other.section != nil
+
+      return true
+    end
+
+#    begin
+#      Demanglers = [  ]
+#      def demangle
+#        return @demangled if @demangled
+#
+#        Demanglers.each do |demangler|
+#          break if (@demangled ||= demangler.demangle(name))
+#        end
+#
+#        # We're going to remove top-namespace specifications as we don't
+#        # need them, but it's easier for the demangler to still emit
+#        # them.
+#        @demangled.gsub!(/(^| |\()::/, '\1') if @demangled
+#
+#        return @demangled ||= name
+#      end
+#    rescue LoadError
+      def demangle
+        return name
+      end
+#    end
+
+    private
+    def version_index
+      return nil if (!@file.has_section?('.gnu.version')) or
+        ( section.is_a?(Integer) and section == Elf::Section::Abs ) or
+        ( section.is_a? Elf::Section and section.name == ".bss" )
+
+      @file['.gnu.version'][@idx]
+    end
+  end
+end