ruby-elf 1.0.3 → 1.0.4

data/lib/elf.rb

@@ -29,7 +29,7 @@ require 'elf/file'
 require 'elf/section'
 
 module Elf
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 
   MagicString = "\177ELF"
 

data/lib/elf/dynamic.rb

@@ -248,7 +248,7 @@ module Elf
     end
 
     # Return the amount of entries in the .dynamic section.
-    def size
+    def count
       load unless @entries
 
       @entries.size

data/lib/elf/file.rb

@@ -87,6 +87,9 @@ module Elf
                 :abi_version, :machine
     attr_reader :string_table
 
+    # raw data access
+    attr_reader :shoff
+
     def read_addr
       case @elf_class
       when Class::Elf32 then read_u32
@@ -196,7 +199,7 @@ module Elf
         @version = read_word
         @entry = read_addr
         @phoff = read_off
-        shoff = read_off
+        @shoff = read_off
         @flags = read_word
         @ehsize = read_half
         @phentsize = read_half
@@ -209,7 +212,7 @@ module Elf
         @sections = {}
 
         @sections_data = []
-        seek(shoff)
+        seek(@shoff)
         for i in 1..shnum
           sectdata = {}
           sectdata[:idx]       = i-1
@@ -264,7 +267,7 @@ module Elf
         raise MissingSection.new(sect_idx_or_name) unless
           @sections_data[sect_idx_or_name]
 
-        @sections[sect_idx_or_name] = Section.read(self, @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]
@@ -287,6 +290,10 @@ module Elf
       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
@@ -363,5 +370,25 @@ module Elf
         @abi_version == other.abi_version and
         @machine == other.machine
     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_EB8) == ARM::EFlags_EB8
+    end
   end
 end

data/lib/elf/gnu.rb

@@ -39,7 +39,7 @@ module Elf
         end
       end
 
-      def size
+      def count
         load unless @versions
 
         @versions.size
@@ -91,7 +91,7 @@ module Elf
         end
       end
 
-      def size
+      def count
         load unless @defined_versions
 
         @defined_versions.size
@@ -150,7 +150,7 @@ module Elf
         end
       end
  
-      def size
+      def count
         load unless @needed_versions
 
         @needed_versions.size

data/lib/elf/section.rb

@@ -39,7 +39,7 @@ module Elf
     Abs        = 0xfff1 # Absolute symbols
     Common     = 0xfff2 # Common symbols
     XIndex     = 0xffff
-    
+
     class UnknownType < Exception
       def initialize(type_id, section_name)
         @type_id = type_id
@@ -55,32 +55,40 @@ module Elf
     # This function assumes that the elf file is aligned ad the
     # start of a section header, and returns the file moved at the
     # start of the next header.
-    def Section.read(elf, sectdata)
+    def Section.read(elf, index, sectdata)
       begin
         if Type::ProcSpecific.include?(sectdata[:type_id])
-          case elf.machine
-          when Elf::Machine::ARM
-            type = Type::ProcARM[sectdata[:type_id]]
-          else
+          begin
+            case elf.machine
+            when Elf::Machine::ARM
+              type = Type::ProcARM[sectdata[:type_id]]
+            else
+              type = Type[sectdata[:type_id]]
+            end
+          rescue Value::OutOfBound
             type = Type[sectdata[:type_id]]
           end
         elsif Type::OsSpecific.include?(sectdata[:type_id])
-          # Unfortunately, even though OS ABIs are well-defined for both
-          # GNU/Linux and Solaris, they don't seem to get used at all.
-          #
-          # For this reason, instead of basing ourselves on (just) the
-          # OS ABI, the name of the section is used to identify the type
-          # of section to use
-
-          # Don't set the name if there is no string table loaded
-          name = elf.string_table ? elf.string_table[sectdata[:name_idx]] : ""
-          if elf.abi == Elf::OsAbi::Solaris or
-              name =~ /^\.SUNW_/
-            type = Type::SunW[sectdata[:type_id]]
-          elsif elf.abi == Elf::OsAbi::Linux or
-              name =~ /^\.gnu\./
-            type = Type::GNU[sectdata[:type_id]]
-          else
+          begin
+            # Unfortunately, even though OS ABIs are well-defined for both
+            # GNU/Linux and Solaris, they don't seem to get used at all.
+            #
+            # For this reason, instead of basing ourselves on (just) the
+            # OS ABI, the name of the section is used to identify the type
+            # of section to use
+
+            # Don't set the name if there is no string table loaded
+            name = elf.string_table ? elf.string_table[sectdata[:name_idx]] : ""
+            if elf.abi == Elf::OsAbi::Solaris or
+                name =~ /^\.SUNW_/
+              type = Type::SunW[sectdata[:type_id]]
+            elsif elf.abi == Elf::OsAbi::Linux or
+                name =~ /^\.gnu\./
+              type = Type::GNU[sectdata[:type_id]]
+            else
+              type = Type[sectdata[:type_id]]
+            end
+          rescue Value::OutOfBound
             type = Type[sectdata[:type_id]]
           end
         else
@@ -96,16 +104,18 @@ module Elf
                             ) if type.nil?
 
       if Type::Class[type]
-        return Type::Class[type].new(elf, sectdata, type)
+        return Type::Class[type].new(elf, index, sectdata, type)
       else
-        return Section.new(elf, sectdata, type)
+        return Section.new(elf, index, sectdata, type)
       end
     end
 
-    attr_reader :offset, :addr, :type, :size, :file
+    attr_reader :file, :index, :type, :addr, :offset, :size
+    attr_reader :addralign, :entsize, :info
 
-    def initialize(elf, sectdata, type)
+    def initialize(elf, index, sectdata, type)
       @file =      elf
+      @index =     index
       @type =      type
       @name =      sectdata[:name_idx]
       @flags_val = sectdata[:flags_val]
@@ -143,6 +153,7 @@ module Elf
 
     # Alias to_s to name so that using this in a string will report the name
     alias :to_s :name
+    alias :to_i :index
 
     def link
       # We didn't get the linked section header yet
@@ -153,18 +164,6 @@ module Elf
       @link
     end
 
-    # Return a set of flag items, easier to check for single elements.
-    def flags
-      return @flags if @flags
-      
-      @flags = Set.new
-      Flags.each do |flag|
-        flags.add(flag) if (@flags_val & flag.val) == flag.val
-      end
-
-      @flags
-    end
-
     def load
       oldpos = @file.tell
       @file.seek(@offset, IO::SEEK_SET)
@@ -193,13 +192,55 @@ module Elf
              0x40000000 => [ :Ordered, 'Special ordering requirement' ],
              0x80000000 => [ :Exclude, 'Section is excluded unless referenced or allocated' ]
            )
-      
+
       # OS-specific flags mask
       MaskOS   = 0x0ff00000
       # Processor-specific flags mask
       MaskProc = 0xf0000000
     end
 
+    # Return a set of flag items, easier to check for single elements.
+    def flags
+      return @flags if @flags
+
+      @flags = Set.new
+      Flags.each do |flag|
+        flags.add(flag) if (@flags_val & flag.val) == flag.val
+      end
+
+      @flags
+    end
+
+    FlagsToChars = [
+                    [Flags::Write, "W"],
+                    [Flags::Alloc, "A"],
+                    [Flags::ExecInstr, "X"],
+                    [Flags::Merge, "M"],
+                    [Flags::Strings, "S"],
+                    [Flags::InfoLink, "I"],
+                    [Flags::LinkOrder, "L"],
+                    [Flags::Group, "G"],
+                    [Flags::TLS, "T" ],
+                    [Flags::Exclude, "E"],
+                   ]
+
+    def flags_s
+      return @flags_s if @flags_s
+
+      @flags_s = FlagsToChars.collect { |flag, char|
+        flags.include?(flag) ? char : ""
+      }.join
+
+      @flags_s << 'o' if (@flags_val & Flags::MaskOS) != 0
+      @flags_s << 'p' if (@flags_val & Flags::MaskProc) != 0
+
+      return @flags_s
+    end
+
+    def flags_i
+      @flags_val
+    end
+
     # Return the nm(1) code for the section.
     #
     # This function is usually mostly used by Elf::Symbol#nm_code. It
@@ -290,7 +331,11 @@ module Elf
 
       class ProcARM < Value
         fill(
-             0x70000003 => [ :ARMAttributes, 'ARM Attributes' ]
+             0x70000001 => [ :ARMExIdx, 'ARM Exception Index' ],
+             0x70000002 => [ :ARMPreemptMap, 'ARM BDAPI DLL dynamic linking pre-emption map' ],
+             0x70000003 => [ :ARMAttributes, 'ARM Attributes' ],
+             0x70000004 => [ :ARMDebugOverlay, 'ARM Debug Overlay' ],
+             0x70000005 => [ :ARMOverlaySection, 'ARM Overlay Table' ]
              )
       end
 

data/lib/elf/symbol.rb

@@ -21,8 +21,6 @@
 # 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/symbol/demangler_gcc3'
-
 module Elf
   class Symbol
     class Binding < Value
@@ -344,20 +342,28 @@ module Elf
       return true
     end
 
-    Demanglers = [ Elf::Symbol::Demangler::GCC3 ]
-    def demangle
-      return @demangled if @demangled
+    begin
+      require 'elf/symbol/demangler_gcc3'
 
-      Demanglers.each do |demangler|
-        break if (@demangled ||= demangler.demangle(name))
-      end
+      Demanglers = [ Elf::Symbol::Demangler::GCC3 ]
+      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
+        # 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
+        return @demangled ||= name
+      end
+    rescue LoadError
+      def demangle
+        return name
+      end
     end
 
     private

data/lib/elf/symboltable.rb

@@ -68,7 +68,7 @@ module Elf
     include ::Enumerable
 
     # Return the number of symbols in the section
-    def size
+    def count
       symbols.size
     end
 

data/lib/elf/tools.rb

@@ -28,197 +28,231 @@ require 'elf'
 # require arguments (in that latter case they are considered on/off
 # switches), and so on.
 
-# Gets the name of the tool
-def self.to_s
-  File.basename($0)
-end
+module Elf
+  class Tool
+    def self.inherited(klass)
+      raise Exception.new("Another Tool has been already defined") if @tool_defined
+      @tool_defined = true
 
-# Output an error message, prefixed with the tool name.
-def self.puterror(string)
-  return if @quiet
+      at_exit do
+        unless $!
+          klass.main
+        end
+      end
+    end
 
-  @output_mutex.synchronize {
-    $stderr.puts "#{to_s}: #{string}"
-  }
-end
+    # Gets the name of the tool
+    def self.to_s
+      File.basename($0)
+    end
 
-# Output a notice about a file, do not prefix with the tool name, do
-# not print if doing recursive analysis
-def self.putnotice(message)
-  return if @quiet or @recursive
+    # Output an error message, prefixed with the tool name.
+    def self.puterror(string)
+      return if @quiet
 
-  @output_mutex.synchronize {
-    $stderr.puts message
-  }
-end
+      @output_mutex.synchronize {
+        $stderr.puts "#{to_s}: #{string}"
+      }
+    end
+
+    # Output a notice about a file, do not prefix with the tool name, do
+    # not print if doing recursive analysis
+    def self.putnotice(message)
+      return if @quiet or @recursive
 
-# Parse the arguments for the tool; it does not parse the @file
-# options, since they are only expected to contain file names,
-# rather than options.
-def self.parse_arguments
-  opts = Options + [
-                    ["--help", "-?", GetoptLong::NO_ARGUMENT],
-                    ["--quiet", "-q", GetoptLong::NO_ARGUMENT],
-                    ["--recursive", "-R", GetoptLong::NO_ARGUMENT],
-                   ]
-
-  opts = GetoptLong.new(*opts)
-  opts.each do |opt, arg|
-    if opt == "--help"
-      # check if we're executing from a tarball or the git repository,
-      # if so we can't use the system man page.
-      manpage = File.expand_path("../../../manpages/#{to_s}.1", __FILE__)
-      manpage = to_s unless File.exist?(manpage)
-      exec("man #{manpage}")
+      @output_mutex.synchronize {
+        $stderr.puts message
+      }
     end
 
-    attrname = opt.gsub(/^--/, "").gsub("-", "_")
-    attrval = arg.size == 0 ? true : arg
-
-    # If there is a function with the same name of the parameter
-    # defined (with a _cb suffix), call that, otherwise set the
-    # attribute with the same name to the given value.
-    cb = method("#{attrname}_cb") rescue nil
-    case
-    when cb.nil?
-      instance_variable_set("@#{attrname}", attrval)
-    when cb.arity == 0
-      raise ArgumentError("wrong number of arguments in callback (0 for 1)") unless
-        arg.size == 0
-      cb.call
-    when cb.arity == 1
-      # fallback to provide a single "true" parameter if there was no
-      # required argument
-      cb.call(attrval)
-    else
-      raise ArgumentError("wrong number of arguments in callback (#{cb.arity} for #{arg.size})")
+    def self.after_options
     end
-  end
 
-  @parsed_options = true
-end
+    # Parse the arguments for the tool; it does not parse the @file
+    # options, since they are only expected to contain file names,
+    # rather than options.
+    def self.parse_arguments
+      opts = GetoptLong.new(*@options)
+      opts.each do |opt, arg|
+        if opt == "--help"
+          # check if we're executing from a tarball or the git repository,
+          # if so we can't use the system man page.
+          manpage = File.expand_path("../../../manpages/#{to_s}.1", __FILE__)
+          manpage = to_s unless File.exist?(manpage)
+          exec("man #{manpage}")
+        end
 
-def self.single_target?
-  raise Exception.new("You can't call this until options are parsed") unless @parsed_options
+        attrname = opt.gsub(/^--/, "").gsub("-", "_")
+        attrval = arg.size == 0 ? true : arg
 
-  # We consider having a single target means that we're given exactly
-  # one argument, and that argument is not a targets' list itself.
-  return (ARGV.size == 1 and ARGV[0] !~ /^@/)
-end
+        # If there is a function with the same name of the parameter
+        # defined (with a _cb suffix), call that, otherwise set the
+        # attribute with the same name to the given value.
+        cb = method("#{attrname}_cb") rescue nil
+        case
+        when cb.nil?
+          instance_variable_set("@#{attrname}", attrval)
+        when cb.arity == 0
+          raise ArgumentError("wrong number of arguments in callback (0 for 1)") unless
+            arg.size == 0
+          cb.call
+        when cb.arity == 1
+          # fallback to provide a single "true" parameter if there was no
+          # required argument
+          cb.call(attrval)
+        else
+          raise ArgumentError("wrong number of arguments in callback (#{cb.arity} for #{arg.size})")
+        end
+      end
 
-def execute(filename)
-  begin
-    analysis(filename)
-  rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR, Elf::File::NotAnELF,
-    Elf::File::InvalidElfClass, Elf::File::InvalidDataEncoding,
-    Elf::File::UnsupportedElfVersion, Elf::File::InvalidOsAbi, Elf::File::InvalidElfType,
-    Elf::File::InvalidMachine => e
-    # The Errno exceptions have their message ending in " - FILENAME",
-    # so we take the FILENAME out and just use the one we know
-    # already.  We also take out the final dot on the phrase so that
-    # we follow the output messages from other tools, like cat.
-    putnotice "#{filename}: #{e.message.gsub(/\.? - .*/, '')}"
-  rescue Exception => e
-    puterror "#{filename}: #{e.message} (#{e.class})\n\t#{e.backtrace.join("\n\t")}"
-    exit -1
-  end
-end
+      @parsed_options = true
+    end
 
-# Try to execute the analysis function on a given filename argument.
-def self.try_execute(filename)
-  begin
-    # if the file name starts with '@', it is not a target, but a file
-    # with a list of targets, so load it with execute_on_file.
-    if filename[0..0] == "@"
-      execute_on_file(filename[1..-1])
-      return
+    def self.single_target?
+      raise Exception.new("You can't call this until options are parsed") unless @parsed_options
+
+      # We consider having a single target means that we're given exactly
+      # one argument, and that argument is not a targets' list itself.
+      return @targets.size == 1
     end
 
-    # find the file type so we don't have to look it up many times; if
-    # we're running a recursive scan, we don't want to look into
-    # symlinks as they might create loops or duplicate content, while
-    # we usually want to check them out if they are given directly in
-    # the list of files to analyse
-    file_stat = if @recursive
-                  File.lstat(filename)
-                else
-                  File.stat(filename)
-                end
-
-    # if the path references a directory, and we're going to run
-    # recursively, descend into that.
-    if @recursive and file_stat.directory?
-      Dir.foreach(filename) do |children|
-        next if children == "." or children == ".."
-        try_execute(File.join(filename, children))
+    def self.execute(filename)
+      begin
+        analysis(filename)
+      rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR, Elf::File::NotAnELF,
+        Elf::File::InvalidElfClass, Elf::File::InvalidDataEncoding,
+        Elf::File::UnsupportedElfVersion, Elf::File::InvalidOsAbi, Elf::File::InvalidElfType,
+        Elf::File::InvalidMachine => e
+        # The Errno exceptions have their message ending in " - FILENAME",
+        # so we take the FILENAME out and just use the one we know
+        # already.  We also take out the final dot on the phrase so that
+        # we follow the output messages from other tools, like cat.
+        putnotice "#{filename}: #{e.message.gsub(/\.? - .*/, '')}"
+      rescue Exception => e
+        puterror "#{filename}: #{e.message} (#{e.class})\n\t#{e.backtrace.join("\n\t")}"
+        exit -1
       end
-    # if the path does not point to a regular file, ignore it
-    elsif not file_stat.file?
-      putnotice "#{filename}: not a regular file"
-    else
-      @execution_threads.add(Thread.new {
-                               execute(filename)
-                             })
     end
-  rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR, Elf::File::NotAnELF => e
-    # The Errno exceptions have their message ending in " - FILENAME",
-    # so we take the FILENAME out and just use the one we know
-    # already.  We also take out the final dot on the phrase so that
-    # we follow the output messages from other tools, like cat.
-    putnotice "#{filename}: #{e.message.gsub(/\.? - .*/, '')}"
-  rescue SystemExit => e
-    exit e.status
-  rescue Exception => e
-    puterror "#{filename}: #{e.message} (#{e.class})\n\t#{e.backtrace.join("\n\t")}"
-    exit -1
-  end
-end
 
-# Execute the analysis function on all the elements of an array.
-def self.execute_on_array(array)
-  array.each do |filename|
-    try_execute(filename)
-  end
-end
+    def self.thread_execute(filename)
+      # If our child set @execution_threads to nil, it doesn't really
+      # support running multithreaded, this is the case for instance
+      # of the link collision harvester script, where the db access
+      # and pkey generation has to be synchronous.
+      unless @execution_threads.nil?
+        @execution_threads.add(Thread.new {
+                                 execute(filename)
+                               })
+      else
+        execute(filename)
+      end
+    end
 
-# Execute the analysis function on all the lines of a file
-def self.execute_on_file(file)
-  file = $stdin if file == "-"
-  file = File.new(file) if file.class == String
+    # Try to execute the analysis function on a given filename argument.
+    def self.try_execute(filename)
+      begin
+        # find the file type so we don't have to look it up many times; if
+        # we're running a recursive scan, we don't want to look into
+        # symlinks as they might create loops or duplicate content, while
+        # we usually want to check them out if they are given directly in
+        # the list of files to analyse
+        file_stat = if @recursive
+                      File.lstat(filename)
+                    else
+                      File.stat(filename)
+                    end
 
-  file.each_line do |line|
-    try_execute(line.chomp("\n"))
-  end
-end
+        # if the path references a directory, and we're going to run
+        # recursively, descend into that.
+        if @recursive and file_stat.directory?
+          Dir.foreach(filename) do |children|
+            next if children == "." or children == ".."
+            try_execute(File.join(filename, children))
+          end
+          # if the path does not point to a regular file, ignore it
+        elsif not file_stat.file?
+          putnotice "#{filename}: not a regular file"
+        else
+          thread_execute(filename)
+        end
+      rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR, Elf::File::NotAnELF => e
+        # The Errno exceptions have their message ending in " - FILENAME",
+        # so we take the FILENAME out and just use the one we know
+        # already.  We also take out the final dot on the phrase so that
+        # we follow the output messages from other tools, like cat.
+        putnotice "#{filename}: #{e.message.gsub(/\.? - .*/, '')}"
+      rescue SystemExit => e
+        exit e.status
+      rescue Exception => e
+        puterror "#{filename}: #{e.message} (#{e.class})\n\t#{e.backtrace.join("\n\t")}"
+        exit -1
+      end
+    end
 
-def self.main
-  begin
-    @output_mutex = Mutex.new
-    @execution_threads = ThreadGroup.new
+    # Execute the analysis function on all the elements of an array.
+    def self.execute_on(param)
+      param = ::File.new(param) if param.is_a? String
+      param = param.read.split(/\r?\n/) if param.is_a? IO
 
-    before_options if respond_to? :before_options
-    parse_arguments
-    after_options if respond_to? :after_options
+      param.each do |filename|
+        try_execute(filename)
+      end
+    end
 
-    if ARGV.size == 0
-      execute_on_file($stdin)
-    else
-      execute_on_array(ARGV)
+    def self.results
     end
 
-    @execution_threads.list.each do |thread|
-      thread.join
+    def self.initialize
+      @output_mutex = Mutex.new
+      @execution_threads = ThreadGroup.new
+
+      @options = [
+                  ["--help", "-?", GetoptLong::NO_ARGUMENT],
+                  ["--quiet", "-q", GetoptLong::NO_ARGUMENT],
+                  ["--recursive", "-R", GetoptLong::NO_ARGUMENT],
+                 ]
     end
 
-    results if respond_to? :results
-  rescue Interrupt
-    puterror "Interrupted"
-    exit 1
-  end
-end
+    def self.main
+      initialize
+
+      begin
+        parse_arguments
+
+        # collect all the arguments passed; if the argument starts
+        # with '@', then open the file and split the lines in further
+        # arguments.
+        @targets = ARGV.collect { |argument|
+          if argument[0..0] == "@"
+            ::File.new(argument[1..-1]).read.split(/\r?\n/)
+          else
+            argument
+          end
+        }.flatten
+
+        after_options
 
-at_exit do
-  unless $!
-    main
+        # if we have no targets (neither direct arguments, nor added
+        # by #after_options, we readthe targets from stdin.
+        if @targets.empty?
+          $stdin.each_line { |input|
+            try_execute(input.sub(/\r?\n/, ''))
+          }
+        else
+          @targets.uniq.each { |target| try_execute(target) }
+        end
+
+        if @execution_threads
+          @execution_threads.list.each do |thread|
+            thread.join
+          end
+        end
+
+        results
+      rescue Interrupt
+        puterror "Interrupted"
+        exit 1
+      end
+    end
   end
 end