ruby-elf 1.0.0

data/bin/elfgrep

@@ -0,0 +1,185 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+# Copyright © 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
+
+require 'elf/tools'
+
+Options = [
+           # Expression to match on the symbol name
+           ["--regexp", "-e", GetoptLong::REQUIRED_ARGUMENT],
+           # Append the version information when matching the symbol
+           # name
+           ["--match-version", "-V", GetoptLong::NO_ARGUMENT],
+           # Don't match undefined symbols
+           ["--no-match-undefined", "-U", GetoptLong::NO_ARGUMENT],
+           # Don't match defined symbols
+           ["--no-match-defined", "-D", GetoptLong::NO_ARGUMENT],
+           # Invert selection, show symbols not matching the
+           # expression
+           ["--invert-match", "-v", GetoptLong::NO_ARGUMENT],
+           # List only files with matches
+           ["--files-with-matches", "-l", GetoptLong::NO_ARGUMENT],
+           # List only files without match
+           ["--files-without-match", "-L", GetoptLong::NO_ARGUMENT],
+           # Print the name of the file for each match
+           ["--with-filename", "-H", GetoptLong::NO_ARGUMENT],
+           # Don't print the name of the file for each match
+           ["--no-filename", "-h", GetoptLong::NO_ARGUMENT],
+           # Only output matches' count
+           ["--count", "-c", GetoptLong::NO_ARGUMENT],
+           # Match fixed strings and not regular expressions
+           ["--fixed-strings", "-F", GetoptLong::NO_ARGUMENT],
+           # Make elfgrep case-insensitive
+           ["--ignore-case", "-i", GetoptLong::NO_ARGUMENT],
+           # Use NULLs to terminate filenames
+           ["--null", "-Z", GetoptLong::NO_ARGUMENT],
+          ]
+
+# We define callbacks for some behaviour-changing options as those
+# will let us consider them positionally, similar to what grep(1)
+# does. If you try -lLl and similar combinations on grep(1), the last
+# one passed is the one to be considered.
+
+def self.fixed_strings_cb
+  @match = :fixed_strings
+end
+
+def self.files_with_matches_cb
+  @show = :files_with_matches
+end
+
+def self.files_without_match_cb
+  @show = :files_without_match
+end
+
+def self.with_filename_cb
+  @print_filename = true
+end
+
+def self.no_filename_cb
+  @print_filename = false
+end
+
+# we make this a method so that we don't have to worry about deciding
+# on the base of how many targets we have; we have to do this
+# because we cannot know, in after_options, whether the user passed
+# @-file lists.
+def self.print_filename
+  @print_filename = !@single_target if @print_filename.nil?
+
+  @print_filename
+end
+
+def self.regexp_cb(pattern)
+  @patterns << pattern
+end
+
+def self.before_options
+  @invert_match = false
+  @match_undefined = true
+  @match_defined = true
+  @show = :full_match
+  @match = :regexp
+
+  @patterns = []
+end
+
+def self.after_options
+  if @patterns.size ==0
+    puterror "you need to provide at least expression"
+    exit -1
+  end
+
+  if @no_match_undefined and @no_match_defined
+    puterror "you need to match at least defined or undefined symbols"
+    exit -1
+  end
+
+  @match_undefined = !@no_match_undefined
+  @match_defined = !@no_match_defined
+
+  regexp_options = @ignore_case ? Regexp::IGNORECASE : 0
+  @regexp = Regexp.union(@patterns.collect { |pattern|
+                           # escape the pattern, so that it works like
+                           # it was a fixed string.
+                           pattern = Regexp.escape(pattern) if @match == :fixed_strings
+
+                           Regexp.new(pattern, regexp_options)
+                         })
+end
+
+def self.analysis(file)
+  if not @print_filename
+    file_prefix = ""
+  else
+    file_prefix = sprintf("%s%s ",
+                          file,
+                          @null ? "\0" : ":")
+  end
+  file_list = sprintf("%s%s",
+                      file,
+                      @null ? "\0" : "\n")
+
+  Elf::File.open(file) do |elf|
+    table = [".dynsym", ".symtab"].find do |table|
+      begin
+        (elf[table].class == Elf::SymbolTable)
+      rescue Elf::File::MissingSection
+        false
+      end
+    end
+
+    if table.nil?
+      putnotice "#{file}: unable to find symbol table"
+      return
+    end
+
+    matches = 0
+    elf[table].each do |symbol|
+      next if
+        (symbol.section == Elf::Section::Abs) or
+        (symbol.name == '') or
+        (symbol.section == Elf::Section::Undef and
+         not @match_undefined) or
+        (symbol.section != Elf::Section::Undef and
+         not @match_defined)
+
+      symname = symbol.name
+      symname += "@#{symbol.version}" if @match_version
+
+      # We don't care where it matches, but we do care that it matches
+      # or not; we use an invert match since we have to further compare
+      # that to @invert_match
+      if (@invert_match == (@regexp =~ symname).nil?)
+        matches = matches+1
+
+        break unless @show == :full_match
+        next if @count
+
+        puts "#{file_prefix}#{symbol.address_string} #{symbol.nm_code rescue '?'} #{symname}"
+      end
+    end
+
+    if @show == :files_with_matches
+      puts file_list if matches > 0
+    elsif @show == :files_without_match
+      puts file_list if matches == 0
+    elsif @count
+      puts "#{file_prefix}#{matches}"
+    end
+  end
+end

data/bin/missingstatic

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+# Copyright © 2008-2010 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
+
+# check for functions that are not used but in their translation unit
+
+require 'elf/tools'
+
+Options = [
+           # Exclude functions with a given prefix (exported functions)
+           ["--exclude-regexp", "-x", GetoptLong::REQUIRED_ARGUMENT],
+           # Only scan hidden symbols, ignore exported ones
+           ["--hidden-only", "-h", GetoptLong::NO_ARGUMENT],
+           # Show the type of symbol (function, variable, constant)
+           ["--show-type", "-t", GetoptLong::NO_ARGUMENT],
+           # Exclude symbols present in a tags file (from exuberant-ctags)
+           ["--exclude-tags", "-X", GetoptLong::REQUIRED_ARGUMENT]
+          ]
+
+def self.exclude_tags_cb(arg)
+  @exclude_names += File.readlines(arg).delete_if do |line|
+    line[0..0] == '!' # Internal exuberant-ctags symbol
+  end.collect do |line|
+    line.split[0]
+  end
+end
+
+def self.exclude_regexp_cb(arg)
+  @exclude_regexps << Regexp.new(arg)
+end
+
+def self.before_options
+  # The main symbol is used by all the standalone executables,
+  # reporting it is pointless as it will always be a false
+  # positive. It cannot be marked static.
+  #
+  # The excluded_names variable will contain also all the used symbols
+  @exclude_names = ["main"]
+  @exclude_regexps = []
+  @hidden_only = false
+  @show_type = false
+end
+
+def self.after_options
+  @all_defined = []
+end
+
+def self.analysis(filename)
+  Elf::File.open(filename) do |elf|
+    if elf.type != Elf::File::Type::Rel
+      putnotice "#{file}: not an object file"
+      next
+    end
+    unless elf.has_section?('.symtab')
+      putnotice "#{file}: no .symtab section found"
+      next
+    end
+
+    # Gather all the symbols, defined and missing in the translation unit
+    elf['.symtab'].each do |sym|
+      if sym.section == Elf::Section::Undef
+        @exclude_names << sym.name
+      elsif sym.bind == Elf::Symbol::Binding::Local
+        next
+      elsif (sym.section.is_a? Elf::Section) or
+          (sym.section == Elf::Section::Common)
+        next if @hidden_only and
+          sym.visibility != Elf::Symbol::Visibility::Hidden
+
+        @all_defined << sym
+      end
+    end
+  end
+end
+
+def self.results
+  @exclude_names.uniq!
+
+  @all_defined.each do |symbol|
+    next if @exclude_names.include? symbol.name
+
+    excluded = false
+    @exclude_regexps.each do |exclude_sym|
+      break if excluded = exclude_sym.match(symbol.name)
+    end
+    next if excluded
+
+    if @show_type
+      begin
+        prefix = "#{symbol.nm_code} "
+      rescue Elf::Symbol::UnknownNMCode => e
+        puterror e.message
+        prefix = "? "
+      end
+    end
+    puts "#{prefix}#{symbol.name} (#{symbol.file.path})"
+  end
+end

data/bin/rbelf-size

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+# Copyright © 2008-2010 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
+
+# replacement for size(1) utility that takes into consideration .rodata sections
+
+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]
+          ]
+
+def self.before_options
+  @relocation_stats = false
+end
+
+def self.after_options
+  @header = true
+end
+
+def self.analysis(file)
+  Elf::File.open(file) do |elf|
+    results = {
+      :exec => 0,
+      :data => 0,
+      :rodata => 0,
+      :relro => 0,
+      :bss => 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|
+      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) and
+            section.flags.include?(Elf::Section::Flags::Alloc))
+        
+        # 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
+      when section.flags.include?(Elf::Section::Flags::Alloc)
+        sectype = :rodata
+      end
+
+      results[sectype] += section.size unless sectype.nil?
+    end
+
+    results[:total] = results.values.inject { |sum, val| sum += val }
+
+    if @relocation_stats
+      relocation_stats(results, file)
+    else
+      standard_size(results, file)
+    end
+  end
+end
+
+def self.relocation_stats(results, file)
+  if @header
+    puts "      shared      private    relocated        ratio   filename"
+    @header = false
+  end
+
+  size_shared = results[:exec] + results[:rodata]
+  size_private = results[:data] + results[:bss]
+  size_relocated = results[:relro]
+
+  ratio = size_shared.to_f/size_relocated
+  ratio = 10 * Math::log10(ratio) if @decibel
+
+  printf "% 12s % 12s % 12s % 12.2f   %s\n", size_shared, size_private, size_relocated, ratio, file
+end
+
+def self.standard_size(results, file)
+  if @header
+    puts "     exec      data    rodata     relro       bss     total filename"
+    @header = false
+  end
+
+  results.each_pair do |key, val|
+    results[key] = val.to_s.rjust(9)
+  end
+
+  puts "#{results[:exec]} #{results[:data]} #{results[:rodata]} #{results[:relro]} #{results[:bss]} #{results[:total]} #{file}"
+end

data/bin/verify-lfs

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+# Copyright © 2010 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
+
+# This script verifies whether a file or a tree of files is using
+# non-LFS interfaces, or mixing non-LFS and LFS interfaces.
+
+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"
+                  ]
+
+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
+    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
+    end
+
+    if use_stat32 and use_stat64
+      @files_mixing << file
+    elsif use_stat32 and not use_stat64
+      @files_nolfs << file
+    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