ruby-elf 1.0.3 → 1.0.4

data/bin/rbelf-read

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+# Copyright © 2008-2011 Diego E. "Flameeyes" Pettenò <flameeyes@gmail.com>
+#
+# 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
+
+# proof-of-concept reimplementation of readelf(1)
+
+require 'elf/tools'
+
+module Elf::Tools
+  class ReadElf < Elf::Tool
+    def self.initialize
+      super
+      @options |= [
+                   ["--all", "-a", GetoptLong::NO_ARGUMENT],
+                   ["--section-headers", "-S", GetoptLong::NO_ARGUMENT],
+                   ["--dynamic", "-d", GetoptLong::NO_ARGUMENT],
+                  ]
+    end
+
+    def self.all_cb
+      @section_headers = true
+      @dynamic = true
+    end
+
+    def self.after_options
+    end
+
+    def self.analysis(file)
+      elf = Elf::File.open(file)
+
+      @addrsize = (elf.elf_class == Elf::Class::Elf32 ? 8 : 16)
+
+      @output_mutex.synchronize {
+        printf("\nFile: %s\n", file) if @targets.size != 1
+        read_sections(elf) if @section_headers
+        read_dynamic(elf) if @dynamic
+      }
+    end
+
+    def self.read_sections(elf)
+      printf("There are %d section headers, starting at offset 0x%x:\n\nSection Headers:\n",
+             elf.sections, elf.shoff)
+
+      printf("[Nr] Name                 Type          Addr             Off      Size     ES Flags Lk Inf Al\n")
+
+      elf.each_section do |section|
+        printf("[%2d] %s %s %0#{@addrsize}x %08x %08x %2d %s %2d %3d %2d\n",
+               section.index,
+               section.name.ljust(20),
+               section.type.mnemonic.upcase.ljust(13),
+               section.addr, section.offset, section.size, section.entsize,
+               section.flags_s.ljust(5), section.link.to_i, section.info, section.addralign)
+      end
+
+      printf("\n")
+    end
+
+    def self.read_dynamic(elf)
+      dynsection = elf[".dynamic"]
+
+      if dynsection.nil?
+        printf("\nThere is no dynamic section in this file.\n")
+        return
+      end
+
+      printf("\nDynamic section at offset 0x%x contains %d entries:\n",
+             dynsection.offset, dynsection.size)
+      printf("  Tag                Type                 Name/Value\n")
+
+      dynsection.each_entry do |entry|
+        case entry.type
+        when Elf::Dynamic::Type::Needed
+          val = "Shared library: [#{entry.parsed}]"
+        when Elf::Dynamic::Type::Auxiliary
+          val = "Auxiliary library: [#{entry.parsed}]"
+        when Elf::Dynamic::Type::SoName
+          val = "Library soname: [#{entry.parsed}]"
+        when Elf::Dynamic::Type::StrSz, Elf::Dynamic::Type::SymEnt,
+          Elf::Dynamic::Type::PltRelSz, Elf::Dynamic::Type::RelASz,
+          Elf::Dynamic::Type::RelAEnt
+
+          val = "#{entry.value} (bytes)"
+        when Elf::Dynamic::Type::VerDefNum, Elf::Dynamic::Type::VerNeedNum, Elf::Dynamic::Type::RelACount
+          val = entry.value
+        when Elf::Dynamic::Type::GNUPrelinked
+          val = entry.parsed.getutc.strftime('%Y-%m-%dT%H:%M:%S')
+        else
+          val = sprintf("0x%x", entry.value)
+        end
+
+        printf(" 0x%016x %-20s %s\n", entry.type.to_i, "(#{entry.type.to_s})", val)
+
+        break if entry.type == Elf::Dynamic::Type::Null
+      end
+    end
+  end
+end

data/bin/rbelf-size

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # -*- mode: ruby; coding: utf-8 -*-
-# Copyright © 2008-2010 Diego E. "Flameeyes" Pettenò <flameeyes@gmail.com>
+# Copyright © 2008-2011 Diego E. "Flameeyes" Pettenò <flameeyes@gmail.com>
 #
 # 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
@@ -20,126 +20,163 @@
 
 require 'elf/tools'
 
-Options = [
-           # Give relocation data for shared object assesment
-           ["--relocation-stats", "-r", GetoptLong::NO_ARGUMENT],
-           # Use deciBel scale for the shared-to-relocated ratio
-           ["--decibel", "-d", GetoptLong::NO_ARGUMENT]
-          ]
+module Elf::Tools
+  class Size < Elf::Tool
+    def self.initialize
+      super
+      @options |= [
+                   # Give relocation data for shared object assesment
+                   ["--relocation-stats", "-r", GetoptLong::NO_ARGUMENT],
+                   # Use deciBel scale for the shared-to-relocated ratio
+                   ["--decibel", "-d", GetoptLong::NO_ARGUMENT],
+                   # Show differences between the first parameter and
+                   # the following.
+                   ["--differential", "-D", GetoptLong::NO_ARGUMENT],
+                  ]
+
+      @relocation_stats = false
+    end
 
-def self.before_options
-  @relocation_stats = false
-end
+    def self.after_options
+      # to properly handle the differential size count, we have to
+      # process all the files in sequence; this means that we cannot
+      # use multithreaded scan here.
+      @execution_threads = nil if @differential
 
-def self.after_options
-  @header = true
-end
+      @processing = []
 
-def self.analysis(file)
-  Elf::File.open(file) do |elf|
-    results = {
-      :exec => 0,
-      :data => 0,
-      :rodata => 0,
-      :relro => 0,
-      :bss => 0,
-      :overhead => 0,
-      :total => 0
-    }
-
-    # Get the size of each section, and then, depending on its type,
-    # flags and eventually name, decide what to sum it to.
-    elf.each_section do |section|
-      # This tool only interests itself with size of sections that are
-      # loaded into memory at runtime, and not those that only impact
-      # the size of the on-disk file.
-      next unless section.flags.include?(Elf::Section::Flags::Alloc)
-
-      case
-      # When the section is NoBits, it is not allocated in the file,
-      # and is only allocated in ram, this is the case of .bss and
-      # .tbss sections.
-      when section.type == Elf::Section::Type::NoBits
-        sectype = :bss
-      # If the section contains executable code, count it separately;
-      # size(1) will count it all as text, but we don't need to do
-      # that.
-      when section.flags.include?(Elf::Section::Flags::ExecInstr)
-        sectype = :exec
-      # If the section is going to be allocated and writeable at
-      # runtime, it is usually a data section, of some kind.
-      #
-      # We check further though since we might want to count it
-      # separately.
-      when section.flags.include?(Elf::Section::Flags::Write)
-        # This makes it GCC-specific but that's just because I
-        # cannot find anything in ELF specs that gives an easy way
-        # to deal with this.
-        #
-        # By all means, .data.rel.ro is just the same as .data, with
-        # the exception of prelinking, where this area can then
-        # become mostly read-only and thus not creating dirty pages.
-        sectype = (section.name =~ /^\.data\.rel\.ro(\..+)?/) ? :relro : :data
-      # A number of sections are loaded into memory on the image but
-      # are not really used for anything beside providing metadata for
-      # link editor and loader; these section are an object's
-      # "overhead" and can usually be reduced by reducing the amount
-      # of symbols exposed by the object itself.
-      when (section.class == Elf::StringTable or
-            section.class == Elf::SymbolTable or
-            section.type == Elf::Section::Type::Dynamic or
-            section.type == Elf::Section::Type::GNU::VerDef or
-            section.type == Elf::Section::Type::GNU::VerNeed or
-            section.type == Elf::Section::Type::GNU::VerSym or
-            section.type == Elf::Section::Type::Hash or
-            section.type == Elf::Section::Type::GNU::Hash)
-        sectype = :overhead
+      results_formats = {:filename => "  %s\n"}
+
+      if @relocation_stats
+        @processing << :relocation_stats
+        @processing << :convert_ratio if @decibel
+        @results_fields = [ :shared, :private, :relocated, :ratio, :filename ]
       else
-        sectype = :rodata
+        @processing << :count_allocated
+        @results_fields = [ :exec, :data, :rodata, :relro, :bss, :overhead, :allocated, :filename ]
       end
 
-      results[sectype] += section.size unless sectype.nil?
+      @processing << :apply_differential if @differential
+      @processing << :print_results
+      @processing << :differential_format if @differential
+
+      printf( (@results_fields.collect { |field| results_formats[field] || "% 12s" }).join(" "),
+              *@results_fields)
+
+      results_formats[:ratio] = "%12.2f" # special format only for printing
+
+      @format = (@results_fields.collect { |field| results_formats[field] || "% 12d" }).join(" ")
     end
 
-    results[:total] = results.values.inject { |sum, val| sum += val }
+    def self.analysis(file)
+      Elf::File.open(file) do |elf|
+        results = {
+          :exec => 0,
+          :data => 0,
+          :rodata => 0,
+          :relro => 0,
+          :bss => 0,
+          :overhead => 0,
+          :allocated => 0
+        }
+
+        # Get the size of each section, and then, depending on its type,
+        # flags and eventually name, decide what to sum it to.
+        elf.each_section do |section|
+          # This tool only interests itself with size of sections that are
+          # loaded into memory at runtime, and not those that only impact
+          # the size of the on-disk file.
+          next unless section.flags.include?(Elf::Section::Flags::Alloc)
+
+          case
+            # When the section is NoBits, it is not allocated in the file,
+            # and is only allocated in ram, this is the case of .bss and
+            # .tbss sections.
+          when section.type == Elf::Section::Type::NoBits
+            sectype = :bss
+            # If the section contains executable code, count it separately;
+            # size(1) will count it all as text, but we don't need to do
+            # that.
+          when section.flags.include?(Elf::Section::Flags::ExecInstr)
+            sectype = :exec
+            # If the section is going to be allocated and writeable at
+            # runtime, it is usually a data section, of some kind.
+            #
+            # We check further though since we might want to count it
+            # separately.
+          when section.flags.include?(Elf::Section::Flags::Write)
+            # This makes it GCC-specific but that's just because I
+            # cannot find anything in ELF specs that gives an easy way
+            # to deal with this.
+            #
+            # By all means, .data.rel.ro is just the same as .data, with
+            # the exception of prelinking, where this area can then
+            # become mostly read-only and thus not creating dirty pages.
+            sectype = (section.name =~ /^\.data\.rel\.ro(\..+)?/) ? :relro : :data
+            # A number of sections are loaded into memory on the image but
+            # are not really used for anything beside providing metadata for
+            # link editor and loader; these section are an object's
+            # "overhead" and can usually be reduced by reducing the amount
+            # of symbols exposed by the object itself.
+          when (section.class == Elf::StringTable or
+                section.class == Elf::SymbolTable or
+                section.type == Elf::Section::Type::Dynamic or
+                section.type == Elf::Section::Type::GNU::VerDef or
+                section.type == Elf::Section::Type::GNU::VerNeed or
+                section.type == Elf::Section::Type::GNU::VerSym or
+                section.type == Elf::Section::Type::Hash or
+                section.type == Elf::Section::Type::GNU::Hash)
+            sectype = :overhead
+          else
+            sectype = :rodata
+          end
+
+          results[sectype] += section.size unless sectype.nil?
+        end
+
+        results[:filename] = file
+
+        @processing.each do |process|
+          method(process).call(results)
+        end
+      end
+    end
 
-    if @relocation_stats
-      relocation_stats(results, file)
-    else
-      standard_size(results, file)
+    def self.count_allocated(results)
+      results[:allocated] = results.values.inject { |sum, val| sum += val rescue sum}
     end
-  end
-end
 
-def self.relocation_stats(results, file)
-  if @header
-    puts "      shared      private    relocated        ratio   filename"
-    @header = false
-  end
+    def self.apply_differential(results)
+      if @first_results.nil?
+        (@first_results = results.dup).delete(:filename)
+        return
+      end
 
-  size_shared = results[:exec] + results[:rodata]
-  size_private = results[:data] + results[:bss]
-  size_relocated = results[:relro]
+      @results_fields.each do |field|
+        results[field] = results[field] - @first_results[field] rescue nil
+      end
+    end
 
-  ratio = size_shared.to_f/size_relocated
-  ratio = 10 * Math::log10(ratio) if @decibel
+    def self.differential_format(results)
+      @format.gsub!(/%( [0-9]+d)/, '%+\1')
+      @processing.delete(:differential_format)
+    end
 
-  printf "% 12s % 12s % 12s % 12.2f   %s\n", size_shared, size_private, size_relocated, ratio, file
-end
+    def self.relocation_stats(results)
+      results[:shared]    = results[:exec] + results[:rodata]
+      results[:private]   = results[:data] + results[:bss]
+      results[:relocated] = results[:relro]
 
-def self.standard_size(results, file)
-  if @header
-    puts "     exec      data    rodata     relro       bss  overhead     total filename"
-    @header = false
-  end
+      results[:ratio]     = results[:shared].to_f/results[:relocated]
+    end
+
+    def self.convert_ratio(results)
+      results[:ratio] = 10 * Math::log10(results[:ratio])
+    end
 
-  printf("% 9d % 9d % 9d % 9d % 9d % 9d % 9d %s\n",
-         results[:exec],
-         results[:data],
-         results[:rodata],
-         results[:relro],
-         results[:bss],
-         results[:overhead],
-         results[:total],
-         file)
+    def self.print_results(results)
+      printf(@format,
+             *(@results_fields.collect { |field| results[field] }))
+    end
+  end
 end

data/bin/verify-lfs

@@ -21,100 +21,105 @@
 
 require 'elf/tools'
 
-Options = [
-           # Scan only object files (rather than non-object files)
-           ["--objects", "-o", GetoptLong::NO_ARGUMENT]
-          ]
-
-SymbolNamesList = [
-                   "__[fl]?xstat",
-                   "statv?fs",
-                   "(|_IO_)f[gs]etpos",
-                   "(read|scan)dir",
-                   "getdirentries",
-                   "mko?stemp",
-                   "(|__)p(read|write)",
-                   "p(read|write)v",
-                   "(send|tmp)file",
-                   "[gs]etrlimit",
-                   "versionsort",
-                   "f?truncate",
-                   "(|f(|re))open",
-                   "openat",
-                   "fseeko",
-                   "ftello",
-                   "lseek",
-                   "glob(|free)",
-                   "ftw",
-                   "lockf"
+module Elf::Tools
+  class VerifyLFS < Elf::Tool
+    SymbolNamesList = [
+                       "__[fl]?xstat",
+                       "statv?fs",
+                       "(|_IO_)f[gs]etpos",
+                       "(read|scan)dir",
+                       "getdirentries",
+                       "mko?stemp",
+                       "(|__)p(read|write)",
+                       "p(read|write)v",
+                       "(send|tmp)file",
+                       "[gs]etrlimit",
+                       "versionsort",
+                       "f?truncate",
+                       "(|f(|re))open",
+                       "openat",
+                       "fseeko",
+                       "ftello",
+                       "lseek",
+                       "glob(|free)",
+                       "ftw",
+                       "lockf"
+                      ]
+
+    SymbolRegex32 = Regexp.union(SymbolNamesList.collect { |sym| /^#{sym}$/ })
+    SymbolRegex64 = Regexp.union(SymbolNamesList.collect { |sym| /^#{sym}64$/ })
+
+    def self.initialize
+      super
+      @options |= [
+                   # Scan only object files (rather than non-object files)
+                   ["--objects", "-o", GetoptLong::NO_ARGUMENT]
                   ]
-
-SymbolNames = "(#{SymbolNamesList.join("|")})"
-
-def self.before_options
-end
-
-def self.after_options
-  @files_mixing = []
-  @files_nolfs = []
-
-  if @objects
-    @elftypes = [ Elf::File::Type::Rel ]
-    @elfdescr = "a relocatable object file"
-    @elftable = ".symtab"
-  else
-    @elftypes = [ Elf::File::Type::Exec, Elf::File::Type::Dyn ]
-    @elfdescr = "an executable or dynamic file"
-    @elftable = ".dynsym"
-  end
-end
-
-def self.analysis(file)
-  Elf::File.open(file) do |elf|
-    unless @elftypes.include? elf.type
-      putnotice "#{file}: not #{@elfdescr}"
-      next
-    end
-
-    if not elf.has_section?(@elftable) or elf[@elftable].class != Elf::SymbolTable
-      putnotice "#{file}: not a dynamically linked file"
-      next
     end
 
-    if elf.elf_class == Elf::Class::Elf64
-      putnotice "#{file}: testing 64-bit ELF files is meaningless"
-      next
+    def self.after_options
+      @files_mixing = []
+      @files_nolfs = []
+
+      if @objects
+        @elftypes = [ Elf::File::Type::Rel ]
+        @elfdescr = "a relocatable object file"
+        @elftable = ".symtab"
+      else
+        @elftypes = [ Elf::File::Type::Exec, Elf::File::Type::Dyn ]
+        @elfdescr = "an executable or dynamic file"
+        @elftable = ".dynsym"
+      end
     end
 
-    use_stat32 = false
-    use_stat64 = false
-
-    elf[@elftable].each do |symbol|
-      next unless symbol.section == Elf::Section::Undef
-
-      use_stat32 ||= (symbol.to_s =~ /^#{SymbolNames}$/)
-      use_stat64 ||= (symbol.to_s =~ /^#{SymbolNames}64$/)
-
-      # avoid running the whole list if we hit both as we cannot hit
-      # _more_
-      break if use_stat32 and use_stat64
+    def self.analysis(file)
+      Elf::File.open(file) do |elf|
+        unless @elftypes.include? elf.type
+          putnotice "#{file}: not #{@elfdescr}"
+          next
+        end
+
+        if not elf.has_section?(@elftable) or elf[@elftable].class != Elf::SymbolTable
+          putnotice "#{file}: not a dynamically linked file"
+          next
+        end
+
+        if elf.elf_class == Elf::Class::Elf64
+          putnotice "#{file}: testing 64-bit ELF files is meaningless"
+          next
+        end
+
+        use_stat32 = false
+        use_stat64 = false
+
+        elf[@elftable].each do |symbol|
+          next unless symbol.section == Elf::Section::Undef
+
+          use_stat32 ||= (symbol.to_s =~ SymbolRegex32)
+          use_stat64 ||= (symbol.to_s =~ SymbolRegex64)
+
+          # avoid running the whole list if we hit both as we cannot hit
+          # _more_
+          break if use_stat32 and use_stat64
+        end
+
+        if use_stat32 and use_stat64
+          @files_mixing << file
+        elsif use_stat32 and not use_stat64
+          @files_nolfs << file
+        end
+      end
     end
 
-    if use_stat32 and use_stat64
-      @files_mixing << file
-    elsif use_stat32 and not use_stat64
-      @files_nolfs << file
+    def self.results
+      if @files_mixing.size > 0
+        puts "The following files are mixing LFS and non-LFS library calls:"
+        puts "  " + @files_mixing.join("\n  ")
+      end
+      if @files_nolfs.size > 0
+        puts "The following files are using non-LFS library calls:"
+        puts "  " + @files_nolfs.join("\n  ")
+      end
     end
   end
 end
-
-def self.results
-  if @files_mixing.size > 0
-    puts "The following files are mixing LFS and non-LFS library calls:"
-    puts "  " + @files_mixing.join("\n  ")
-  end
-  if @files_nolfs.size > 0
-    puts "The following files are using non-LFS library calls:"
-    puts "  " + @files_nolfs.join("\n  ")
-  end
-end