ruby-elf 1.0.7 → 1.0.8

data/bin/elfgrep

@@ -1,246 +0,0 @@
-#!/usr/bin/env ruby
-# -*- mode: ruby; coding: utf-8 -*-
-# Copyright © 2011 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
-
-require 'elf/tools'
-
-module Elf::Tools
-  class ElfGrep < Elf::Tool
-    def self.initialize
-      super
-
-      @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
-                   ["--match-undefined", "-U", GetoptLong::NO_ARGUMENT],
-                   # Don't match defined symbols
-                   ["--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],
-                   # read the list of patterns from the given file
-                   ["--file", "-f", GetoptLong::REQUIRED_ARGUMENT],
-                   # match the whole symbol
-                   ["--symbol-regexp", "-s", GetoptLong::NO_ARGUMENT],
-                  ]
-
-      @invert_match = false
-      @show = :full_match
-      @match = :regexp
-      @match_symbols = nil
-
-      @patterns = []
-      @pattern_is_first = true
-    end
-
-    # 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.match_undefined_cb
-      if @match_symbols == :defined
-        @match_symbols = :all
-      else
-        @match_symbols = :undefined
-      end
-    end
-
-    def self.match_defined_cb
-      if @match_symbols == :undefined
-        @match_symbols = :all
-      else
-        @match_symbols = :defined
-      end
-    end
-
-    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
-
-    def self.regexp_cb(pattern)
-      @pattern_is_first = false
-
-      @patterns << pattern
-    end
-
-    def self.file_cb(filename)
-      @pattern_is_first = false
-
-      @patterns += File.readlines(filename).
-        each { |l| l.strip! }.
-        reject { |l| l.empty? }
-    end
-
-    def self.after_options
-      if @no_match_undefined and @no_match_defined
-        puterror "you need to match at least defined or undefined symbols"
-        exit -1
-      end
-
-      @match_undefined = @match_symbols != :defined
-      @match_defined = @match_symbols != :undefined
-
-      # if we don't have listed patterns yet (i.e. no -e option), let's
-      # check whether we have at least one argument and if that argument
-      # doesn't start with '@'. If we have no arguments, the targets are
-      # to be given by stdin, and that won't include the actual pattern,
-      # if we have an @-prefixed argument, that's a list of targets and
-      # can't include the pattern either.
-      if (@pattern_is_first and
-          @targets.size >= 1 and
-          @targets[0] !~ /^@/)
-
-        @patterns << @targets.delete_at(0)
-      end
-
-      if @patterns.size == 0
-        puterror "you need to provide at least expression"
-        exit -1
-      end
-
-      @print_filename = (@recursive or @targets.size > 1) if @print_filename.nil?
-      @file_prefix_fmt = @print_filename ? "%s#{@null ? "\0" : ":"} " : ""
-      @file_list_fmt = "%s#{@null ? "\0" : "\n"}"
-
-      regexp_options = @ignore_case ? Regexp::IGNORECASE : 0
-      regexps = @patterns.collect { |pattern|
-        if @match == :fixed_strings
-          pattern.split(/\r?\n/).collect { |string|
-            Regexp.new(Regexp.escape(string), regexp_options)
-          }
-        else
-          Regexp.new(pattern, regexp_options)
-        end
-      }.flatten
-
-      if @symbol_regexp
-        # if we're matching a whole symbol name we need the longest
-        # match, and Ruby's union of regexp does _not_ enforce that,
-        # so we have to do it the long way.
-
-        @match_lambda = proc { |symbol|
-          longest_match = ""
-
-          regexps.each { |re|
-            m = re.match(symbol)
-            longest_match = m[0] unless (m.nil? or m[0].length < longest_match.length)
-          }
-
-          (longest_match != symbol) == @invert_match
-        }
-      else
-        # if we're just doing a loose match, unite the regexps and do
-        # it the fast way.
-        regexp = Regexp.union(regexps)
-
-        @match_lambda = proc { |symbol|
-          regexp.match(symbol).nil? == @invert_match
-        }
-      end
-    end
-
-    def self.analysis(file)
-      file_prefix = sprintf(@file_prefix_fmt, file)
-      file_list = sprintf(@file_list_fmt, file)
-
-      Elf::File.open(file) do |elf|
-        table = [".dynsym", ".symtab"].find do |table|
-          begin
-            (elf[table].class == Elf::SymbolTable)
-          rescue Elf::File::MissingSection, Elf::File::MissingStringTable
-            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
-
-          if (@match_lambda.call(symname))
-            matches = matches+1
-
-            break unless @show == :full_match
-            next if @count
-
-            printf("%s%#{elf.address_print_size}s %s %s\n",
-                  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
-  end
-end

data/bin/missingstatic

@@ -1,113 +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
-
-# check for functions that are not used but in their translation unit
-
-require 'elf/tools'
-
-module Elf::Tools
-  class MissingStatic < Elf::Tool
-    def self.initialize
-      super
-      @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]
-                  ]
-
-      # List of patterns to exclude; this include all the used
-      # symbols, the entrypoints to the system's dynamic loader, and
-      # those provided by the user as to be ignored.
-      #
-      # For technical limits, we have two arrays, one includes all the
-      # regular expressions given by the user, the other is a list of
-      # full strings matching.
-      @exclude_patterns = []
-      @exclude_symbols = Set.new([ "main" ])
-
-      @hidden_only = false
-      @show_type = false
-
-      @all_defined = []
-    end
-
-    def self.exclude_tags_cb(arg)
-      @exclude_symbols |= 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_patterns << Regexp.new(arg)
-    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_symbols << 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_patterns << Regexp.union(@exclude_symbols.collect { |sym| /^#{Regexp.escape(sym)}$/ })
-      exclusions = Regexp.union(@exclude_patterns)
-
-      @all_defined.each do |symbol|
-        next if symbol.name =~ exclusions
-
-        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
-  end
-end

data/bin/rbelf-nm

@@ -1,113 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
-# Copyright © 2007-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
-
-# bsd-nm implementation based on elf.rb (very limited)
-
-require 'elf/tools'
-require 'getoptlong'
-
-module Elf::Tools
-  class NM < Elf::Tool
-
-    def self.initialize
-      super
-      @options |= [
-                   ["--dynamic", "-D", GetoptLong::NO_ARGUMENT],
-                   ["--demangle", "-C", GetoptLong::NO_ARGUMENT],
-                   ["--sort-by", "-S", GetoptLong::REQUIRED_ARGUMENT],
-                   ["--show-version", "-V", GetoptLong::NO_ARGUMENT],
-                  ]
-
-      @scan_section = '.symtab'
-      @demangle = false
-      @exitval = 0
-      @show_version = false
-
-      @sort = :name
-    end
-
-    def self.dynamic_cb
-      @scan_section = '.dynsym'
-    end
-
-    def self.sort_by_cb(attr)
-      case attr
-      when 'address'
-        @sort = :address
-      when 'name'
-        @sort = :name
-      when 'none'
-        @sort = nil
-      else
-        puterror "invalid sort attribute: #{attr}"
-        exit -1
-      end
-    end
-
-    def self.analysis(file)
-      symbols = []
-
-      Elf::File.open(file) do |elf|
-        if not elf.has_section? @scan_section
-          puterror "No symbols"
-          @exitval = 1
-          return
-        end
-
-        elf[@scan_section].each do |sym|
-          next if sym.name == ''
-          begin
-            code = sym.nm_code
-          rescue Elf::Symbol::UnknownNMCode => e
-            puterror(e.message)
-            code = "?"
-          end
-
-          name = @demangle ? sym.demangle : sym.name
-
-          if @show_version and sym.version
-            name = sprintf("%s@%s%s",
-                           name,
-                           sym.version_default? ? '@' : '',
-                           sym.version)
-          end
-
-          symbols << {
-            :address => sym.address_string,
-            :code => code,
-            :name => name
-          }
-        end
-
-        symbols.sort! { |x, y| x[@sort] <=> y[@sort] } unless @sort.nil?
-
-        format_sym = "%#{elf.address_print_size}s %s %s\n"
-        @output_mutex.synchronize {
-          symbols.each do |sym|
-            printf(format_sym,
-                   sym[:address], sym[:code], sym[:name])
-          end
-        }
-      end
-    end
-
-    def self.results
-      exit @exitval
-    end
-  end
-end