ruby-elf 1.0.7 → 1.0.8

data/README.md

@@ -0,0 +1,64 @@
+Ruby-Elf
+========
+
+[![Flattr this!](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/thing/27866/Ruby-Elf)
+
+Ruby-Elf is a pure-Ruby library for parse and fetch information about
+ELF format used by Linux, FreeBSD, Solaris and other Unix-like
+operating systems, and include a set of analysis tools helpful for
+both optimisations and verification of compiled ELF files.
+
+The library allows access to all the details of the ELF files (class,
+type, architecture OS), and also implements Ruby-style access to the
+most important sections in ELF files, such as symbol and string
+tables, as well as dynamic information. Furthermore it implements
+support for accessing extensions specifics for instance to the GNU
+loader such as symbol version information.
+
+Tools
+-----
+
+To complement the library raw access, the project also ships with a
+number of tools, designed to analyse compiled code, in either
+relocated object or final (executable or shared object) form. These
+include both optimisation and verification tools:
+
+ * `cowstats`: allows identification and assessment of CoW data
+   objects inside ELF relocatable files. Should be used to reduce the
+   memory impact of a shared library used by many processes on the
+   system.
+
+ * `rbelf-size`: implements an alternative approach for the size
+   command available on standard Unix systems (as provided by binutils
+   or elfutils packages in most Linux distributions), that focus more
+   on relocation caused by PIC than the actual shared memory sizes.
+
+ * `rbelf-nm`: implements a quasi-compatible `nm(1)` command, more
+   resilient than GNU `nm` and more informative than the elfutils
+   variant.
+ 
+ * `verify-lfs`: checks executables and shared objects, or
+   alternatively relocatable object files, for LFS compliancy,
+   reporting those that don't make use of the largefile-compatible
+   interfaces or that mix old and new ones.
+ 
+ * `elfgrep`: looks for defined or required symbols in dynamic
+   executables and shared objects, with a command syntax similar to
+   the standard `grep` tool.
+   
+License
+-------
+
+Due to derivation, library and tools are released under the GNU GPL-2
+license, or later. See the [`COPYING`](COPYING) file for the complete
+text.
+
+Resources
+---------
+
+You can find the source code for the package at
+[GitHub](https://github.com/Flameeyes/ruby-elf) — previously at
+[Gitorious](https://gitorious.org/ruby-elf).
+
+Development and file releases are on
+[Rubyforge](http://rubyforge.org/projects/ruby-elf/).

data/lib/elf.rb

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

data/ruby-elf.gemspec

@@ -0,0 +1,29 @@
+# -*- ruby -*- coding: utf-8 -*-
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'elf'
+
+Gem::Specification.new do |s|
+  s.name = 'ruby-elf'
+  s.version = Elf::VERSION
+  s.summary = "Pure Ruby ELF file parser and utilities"
+
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.homepage = "http://www.flameeyes.eu/projects/ruby-elf"
+  s.license = "GPL-2 or later"
+  s.author = "Diego Elio Pettenò"
+  s.email = "flameeyes@flameeyes.eu"
+
+  s.description = <<EOF
+Ruby-Elf is a pure-Ruby library for parse and fetch information about
+ELF format used by Linux, FreeBSD, Solaris and other Unix-like
+operating systems, and include a set of analysis tools helpful for
+both optimisations and verification of compiled ELF files.
+EOF
+
+  s.files  = %w{COPYING README.md DONATING ruby-elf.gemspec}
+  s.files += Dir['lib/**/*.rb']
+  s.files += Dir['bin/**/*.rb']
+  s.files += Dir['tools/**/*.rb']
+  s.files += Dir['manpages/*.1']
+end

metadata

@@ -1,120 +1,84 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: ruby-elf
-version: !ruby/object:Gem::Version 
-  hash: 25
+version: !ruby/object:Gem::Version
+  version: 1.0.8
   prerelease: 
-  segments: 
-  - 1
-  - 0
-  - 7
-  version: 1.0.7
 platform: ruby
-authors: 
-- "Diego Elio Petten\xC3\xB2"
+authors:
+- Diego Elio Pettenò
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-12-27 00:00:00 Z
+date: 2013-02-20 00:00:00.000000000 Z
 dependencies: []
+description: ! 'Ruby-Elf is a pure-Ruby library for parse and fetch information about
 
-description: |
-  Ruby-Elf is a pure-Ruby library for parse and fetch information about
   ELF format used by Linux, FreeBSD, Solaris and other Unix-like
+
   operating systems, and include a set of analysis tools helpful for
+
   both optimisations and verification of compiled ELF files.
 
+'
 email: flameeyes@flameeyes.eu
-executables: 
-- verify-lfs
-- rbelf-size
-- missingstatic
-- rbelf-nm
-- elfgrep
-- cowstats
-- rbelf-read
+executables: []
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - COPYING
+- README.md
 - DONATING
-- bin/cowstats
-- bin/elfgrep
-- bin/missingstatic
-- bin/rbelf-nm
-- bin/rbelf-read
-- bin/rbelf-size
-- bin/verify-lfs
-- extras/README.extras
-- extras/bindings-parsers.rb
+- ruby-elf.gemspec
 - lib/bytestream-reader.rb
 - lib/elf.rb
-- lib/elf/dynamic.rb
+- lib/elf/symbol.rb
 - lib/elf/file.rb
 - lib/elf/gnu.rb
-- lib/elf/section.rb
-- lib/elf/stringtable.rb
 - lib/elf/sunw.rb
-- lib/elf/symbol.rb
-- lib/elf/symboltable.rb
+- lib/elf/section.rb
 - lib/elf/tools.rb
-- lib/elf/utils/loader.rb
+- lib/elf/dynamic.rb
 - lib/elf/utils/offsettable.rb
 - lib/elf/utils/pool.rb
+- lib/elf/utils/loader.rb
+- lib/elf/stringtable.rb
 - lib/elf/value.rb
-- manpages/cowstats.1.xml
-- manpages/elfgrep.1.xml
-- manpages/missingstatic.1.xml
-- manpages/rbelf-nm.1.xml
-- manpages/rbelf-size.1.xml
-- manpages/verify-lfs.1.xml
+- lib/elf/symboltable.rb
 - tools/assess_duplicate_save.rb
 - tools/link-collisions/harvest.rb
-- tools/link-collisions/known-broken
-- tools/link-collisions/multimplementations
 - tools/link-collisions/suppress.rb
-- tools/link-collisions/suppressions
 - tools/rbelf-lddtree.rb
-- manpages/missingstatic.1
+- manpages/rbelf-nm.1
 - manpages/verify-lfs.1
+- manpages/rbelf-size.1
+- manpages/missingstatic.1
 - manpages/elfgrep.1
 - manpages/cowstats.1
-- manpages/rbelf-size.1
-- manpages/rbelf-nm.1
 homepage: http://www.flameeyes.eu/projects/ruby-elf
-licenses: 
+licenses:
 - GPL-2 or later
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-requirements: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
 - none
-rubyforge_project: ruby-elf
+rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Pure Ruby ELF file parser and utilities
 test_files: []
-
+has_rdoc: 

data/bin/cowstats

@@ -1,266 +0,0 @@
-#!/usr/bin/env ruby
-# -*- mode: ruby; coding: utf-8 -*-
-# Copyright © 2008-2010 Diego Elio Pettenò <flameeyes@flameeyes.eu>
-#
-# 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
-
-# simple script to check for variables in copy-on-write sections
-
-require 'elf/tools'
-
-module Elf::Tools
-  class CoWStats < Elf::Tool
-
-    def self.initialize
-      super
-      @options |= [
-                   # Only show statistics for the various files
-                   ["--statistics", "-s", GetoptLong::NO_ARGUMENT],
-                   # Show the total size of COW pages
-                   ["--total", "-t", GetoptLong::NO_ARGUMENT],
-                   # Ignore C++ "false positives" (vtables and typeinfo)
-                   ["--ignore-cxx", "-x", GetoptLong::NO_ARGUMENT ],
-                   # Ignore Profiling false positives
-                   ["--ignore-profiling", "-p", GetoptLong::NO_ARGUMENT ],
-                   # Ignore .data.rel.ro relocated constants
-                   ["--ignore-data-rel-ro", "-r", GetoptLong::NO_ARGUMENT ],
-                   # Decide sorting column
-                   ["--sort-by", "-S", GetoptLong::REQUIRED_ARGUMENT ]
-                  ]
-
-      @statistics = false
-      @total = false
-      @ignore_cxx = false
-      @ignore_profiling = false
-      @ignore_data_rel_ro = false
-
-      @results_sorter = Proc.new do |x, y|
-        # 0 is the filename
-        x[0] <=> y[0]
-      end
-
-      @files_info = {}
-
-      @data_total = 0
-      @bss_total = 0
-      @rel_total = 0
-      @relro_total = 0
-    end
-
-    def self.sort_by_cb(column)
-      case column
-      when '.bss'
-        @results_sorter = Proc.new do |x, y|
-          x[1][:bss_size] <=> y[1][:bss_size]
-        end
-      when '.data'
-        @results_sorter = Proc.new do |x, y|
-          x[1][:data_size] <=> y[1][:data_size]
-        end
-      when '.data.rel'
-        @results_sorter = Proc.new do |x, y|
-          x[1][:rel_size] <=> y[1][:rel_size]
-        end
-      when '.data.rel.ro'
-        @results_sorter = Proc.new do |x, y|
-          x[1][:relro_size] <=> y[1][:relro_size]
-        end
-      else
-        puterror "invalid sort column: #{column}"
-        exit -1
-      end
-    end
-
-    def self.analysis(file)
-      data_vars = []
-      data_size = 0
-      bss_vars = []
-      bss_size = 0
-      rel_vars = []
-      rel_size = 0
-      relro_vars = []
-      relro_size = 0
-      
-      Elf::File.open(file) do |elf|
-        if elf.type != Elf::File::Type::Rel
-          putnotice "#{file}: not an object file"
-          next
-        end
-        if not elf.has_section?(".symtab")
-          putnotice "#{file}: no .symtab section found"
-          next
-        end
-
-        elf['.symtab'].each do |symbol|
-          # Ignore undefined, absolute and common symbols.
-          next unless symbol.section.is_a? Elf::Section
-          # When the symbol name is empty, it refers to the
-          # section itself.
-          next if symbol.name == ""
-
-          # Ignore C++ vtables and other symbols when requested
-          next if @ignore_cxx and symbol.name =~ /^_ZT[VI](N[0-9]+[A-Z_].*)*[0-9]+[A-Z_].*/
-          # Ignore profiling symbols when requested by user
-          next if @ignore_profiling and symbol.name =~ /^__gcov_/
-          
-          # If the section is NoBits, then it's .bss or equivalent, handle
-          # and skip right away.
-          if symbol.section.type == Elf::Section::Type::NoBits
-            bss_vars << symbol unless @statistics
-            bss_size += symbol.size
-            next
-          end
-
-          # Ignore executable code (.text, .init, .fini)
-          next if symbol.section.flags.include? Elf::Section::Flags::ExecInstr
-          # Ignore read-only sections (.rodata)
-          next unless symbol.section.flags.include? Elf::Section::Flags::Write
-          # Ignore non-allocated sections (all data sections are allocated)
-          next unless symbol.section.flags.include? Elf::Section::Flags::Alloc
-
-          # Until I can find a way to distinguish between relocated and
-          # non-relocated sections, still use the name to choose between
-          # them. If the name is not in this list, at least warn now
-          # about it.
-          #
-          # The “l” prefix is used by Sun's compiler for x64-specific
-          # sections that can hold over 2GiB of data. They don't change
-          # for what we're concerned.
-          case symbol.section.name
-          when /^\.l?data\.rel\.ro(\..*)?/
-            unless @inore_data_rel_ro
-              relro_vars << symbol unless @statistics
-              relro_size += symbol.size
-            end
-          when /^\.l?data\.rel(\..*)?/, /^\.picdata/
-            rel_vars << symbol unless @statistics
-            rel_size += symbol.size
-          when /^\.l?t?data(\.local)?(\..*)?/
-            data_vars << symbol unless @statistics
-            data_size += symbol.size
-          else
-            puterror "symbol #{symbol.name} in unknown section #{symbol.section.name}"
-          end
-        end
-        
-      end
-
-      return unless (data_size + bss_size + rel_size + relro_size ) > 0
-
-      if @total
-        @data_total += data_size
-        @bss_total += bss_size
-        @rel_total += rel_size
-        @relro_total += relro_size
-      end
-      
-      if @statistics
-        @files_info[file] = {
-          :data_size => data_size,
-          :bss_size => bss_size,
-          :rel_size => rel_size,
-          :relro_size => relro_size
-        }
-        return
-      end
-
-      @output_mutex.synchronize do
-        puts "Processing file #{file}"
-        
-        if bss_vars.length > 0
-          puts "  The following variables aren't initialised (Copy-On-Write):"
-          bss_vars.each do |sym|
-            puts "    #{sym} (size: #{sym.size})"
-          end
-        end
-        
-        if data_vars.length > 0
-          puts "  The following variables are writable (Copy-On-Write):"
-          data_vars.each do |sym|
-            puts "    #{sym} (size: #{sym.size})"
-          end
-        end
-        
-        if rel_vars.length > 0
-          puts "  The following variables need runtime relocation (Copy-On-Write):"
-          rel_vars.each do |sym|
-            puts "    #{sym} (size: #{sym.size})"
-          end
-        end
-        
-        if relro_vars.length > 0
-          puts "  The following constants need runtime relocation (Prelinkable Copy-On-Write):"
-          relro_vars.each do |sym|
-            puts "    #{sym} (size: #{sym.size})"
-          end
-        end
-        
-        if @total
-          puts "  Total non-initialised variables size: #{bss_size}" unless bss_size == 0
-          puts "  Total writable variables size: #{data_size}" unless data_size == 0
-          puts "  Total variables needing runtime relocation size: #{rel_size}" unless rel_size == 0
-          unless @ignore_data_rel_ro
-            puts "  Total constants needing runtime relocation size: #{relro_size}" unless relro_size == 0
-          end
-        end
-      end
-    end
-
-    def self.results
-      if @statistics
-        file_lengths = ["File name".length]
-        bss_lengths  = [".bss size".length]
-        data_lengths = [".data size".length]
-        rel_lengths  = [".data.rel size".length]
-        relro_lengths  = [".data.rel.ro size".length] unless @no_datalrero
-        @files_info.each_pair do |file, info|
-          file_lengths << file.length
-          bss_lengths  << info[:bss_size] .to_s.length
-          data_lengths << info[:data_size].to_s.length
-          rel_lengths  << info[:rel_size] .to_s.length
-          relro_lengths<< info[:relro_size] .to_s.length
-        end
-
-        maxlen       = file_lengths.max
-        max_bss_len  = bss_lengths .max
-        max_data_len = data_lengths.max
-        max_rel_len  = rel_lengths .max
-        max_relro_len= relro_lengths .max
-
-        datarelro_header = @ignore_data_rel_ro ? "" : " | #{'.data.rel.ro size'.ljust max_relro_len}"
-        puts "#{'File name'.ljust maxlen} | #{'.bss size'.ljust max_data_len} | #{'.data size'.ljust max_data_len} | #{'.data.rel size'.ljust max_rel_len}#{datarelro_header}"
-
-        (@files_info.sort &@results_sorter).each do |file, info|
-          datarelro_line = @ignore_data_rel_ro ? "" : "   #{info[:relro_size].to_s.rjust max_relro_len}"
-          puts "#{file.ljust maxlen}   #{info[:bss_size].to_s.rjust max_bss_len}   #{info[:data_size].to_s.rjust max_data_len}   #{info[:rel_size].to_s.rjust max_rel_len}#{datarelro_line}"
-        end
-      end
-
-      if @total
-        data_total_real = @data_total > 0 ? ((@data_total/4096) + (@data_total % 4096 ? 1 : 0)) * 4096 : 0
-        bss_total_real = @bss_total > 0 ? ((@bss_total/4096) + (@bss_total % 4096 ? 1 : 0)) * 4096 : 0 
-        rel_total_real = @rel_total > 0 ? ((@rel_total/4096) + (@rel_total % 4096 ? 1 : 0)) * 4096 : 0
-        relro_total_real = @relro_total > 0 ? ((@relro_total/4096) + (@relro_total % 4096 ? 1 : 0)) * 4096 : 0
-
-        puts "Totals:"
-        puts "    #{@bss_total} (#{bss_total_real} \"real\") bytes of non-initialised variables."
-        puts "    #{@data_total} (#{data_total_real} \"real\") bytes of writable variables."
-        puts "    #{@rel_total} (#{rel_total_real} \"real\") bytes of variables needing runtime relocation."
-        puts "    #{@relro_total} (#{relro_total_real} \"real\") bytes of constants needing runtime relocation." unless @no_datalrero
-        puts "  Total #{@data_total+@bss_total+@rel_total+@relro_total} (#{data_total_real+bss_total_real+rel_total_real+relro_total_real} \"real\") bytes of variables in copy-on-write sections"
-      end
-    end
-  end
-end