ruby-elf 1.0.3 → 1.0.4

data/bin/elfgrep

@@ -18,169 +18,190 @@
 
 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
+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],
+                  ]
+
+      @invert_match = false
+      @show = :full_match
+      @match = :regexp
+      @match_symbols = nil
+
+      @patterns = []
+    end
 
-def self.files_with_matches_cb
-  @show = :files_with_matches
-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.files_without_match_cb
-  @show = :files_without_match
-end
-
-def self.with_filename_cb
-  @print_filename = true
-end
+    def self.match_undefined_cb
+      if @match_symbols == :defined
+        @match_symbols = :all
+      else
+        @match_symbols = :undefined
+      end
+    end
 
-def self.no_filename_cb
-  @print_filename = false
-end
+    def self.match_defined_cb
+      if @match_symbols == :undefined
+        @match_symbols = :all
+      else
+        @match_symbols = :defined
+      end
+    end
 
-def self.regexp_cb(pattern)
-  @patterns << pattern
-end
+    def self.fixed_strings_cb
+      @match = :fixed_strings
+    end
 
-def self.before_options
-  @invert_match = false
-  @match_undefined = true
-  @match_defined = true
-  @show = :full_match
-  @match = :regexp
+    def self.files_with_matches_cb
+      @show = :files_with_matches
+    end
 
-  @patterns = []
-end
+    def self.files_without_match_cb
+      @show = :files_without_match
+    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
+    def self.with_filename_cb
+      @print_filename = true
+    end
 
-  @match_undefined = !@no_match_undefined
-  @match_defined = !@no_match_defined
+    def self.no_filename_cb
+      @print_filename = false
+    end
 
-  # 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 (@patterns.size == 0 and
-      ARGV.size >= 1 and
-      ARGV[0] !~ /^@/)
+    def self.regexp_cb(pattern)
+      @patterns << pattern
+    end
 
-    @patterns << ARGV.delete_at(0)
-  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
 
-  if @patterns.size == 0
-    puterror "you need to provide at least expression"
-    exit -1
-  end
+      @match_undefined = @match_symbols != :defined
+      @match_defined = @match_symbols != :undefined
 
-  @print_filename = true if @print_filename.nil? and not single_target?
-  @file_prefix_fmt = @print_filename ? "%s#{@null ? "\0" : ":"} " : ""
-  @file_list_fmt = "%s#{@null ? "\0" : "\n"}"
-
-  regexp_options = @ignore_case ? Regexp::IGNORECASE : 0
-  @regexp = Regexp.union(@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)
-end
+      # 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 (@patterns.size == 0 and
+          @targets.size >= 1 and
+          @targets[0] !~ /^@/)
 
-def self.analysis(file)
-  file_prefix = sprintf(@file_prefix_fmt, file)
-  file_list = sprintf(@file_list_fmt, file)
+        @patterns << @targets.delete_at(0)
+      end
 
-  Elf::File.open(file) do |elf|
-    table = [".dynsym", ".symtab"].find do |table|
-      begin
-        (elf[table].class == Elf::SymbolTable)
-      rescue Elf::File::MissingSection
-        false
+      if @patterns.size == 0
+        puterror "you need to provide at least expression"
+        exit -1
       end
-    end
 
-    if table.nil?
-      putnotice "#{file}: unable to find symbol table"
-      return
+      @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
+      @regexp = Regexp.union(@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)
     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}"
+    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
+
+          # 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
-
-    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

@@ -20,93 +20,94 @@
 
 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]
-          ]
+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]
+                  ]
 
-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
+      # 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" ])
 
-def self.exclude_regexp_cb(arg)
-  @exclude_regexps << Regexp.new(arg)
-end
+      @hidden_only = false
+      @show_type = false
 
-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
+      @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
+    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
-    unless elf.has_section?('.symtab')
-      putnotice "#{file}: no .symtab section found"
-      next
+
+    def self.exclude_regexp_cb(arg)
+      @exclude_patterns << Regexp.new(arg)
     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
+    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
 
-        @all_defined << sym
+        # 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
-  end
-end
-
-def self.results
-  @exclude_names.uniq!
 
-  @all_defined.each do |symbol|
-    next if @exclude_names.include? symbol.name
+    def self.results
+      @exclude_patterns << Regexp.union(@exclude_symbols.collect { |sym| /^#{Regexp.escape(sym)}$/ })
+      exclusions = Regexp.union(@exclude_patterns)
 
-    excluded = false
-    @exclude_regexps.each do |exclude_sym|
-      break if excluded = exclude_sym.match(symbol.name)
-    end
-    next if excluded
+      @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 = "? "
+        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
-    puts "#{prefix}#{symbol.name} (#{symbol.file.path})"
   end
 end