ruby-elf 1.0.0 → 1.0.1

data/bin/elfgrep

@@ -74,16 +74,6 @@ 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
@@ -99,11 +89,6 @@ def self.before_options
 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
@@ -112,27 +97,43 @@ def self.after_options
   @match_undefined = !@no_match_undefined
   @match_defined = !@no_match_defined
 
+  # 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] !~ /^@/)
+
+    @patterns << ARGV.delete_at(0)
+  end
+
+  if @patterns.size == 0
+    puterror "you need to provide at least expression"
+    exit -1
+  end
+
+  @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|
-                           # 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)
-                         })
+                           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
 
 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")
+  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|

data/bin/rbelf-size

@@ -43,12 +43,18 @@ def self.analysis(file)
       :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
@@ -65,9 +71,7 @@ def self.analysis(file)
       #
       # 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))
-        
+      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.
@@ -76,7 +80,21 @@ def self.analysis(file)
         # 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)
+      # 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
 
@@ -111,13 +129,17 @@ end
 
 def self.standard_size(results, file)
   if @header
-    puts "     exec      data    rodata     relro       bss     total filename"
+    puts "     exec      data    rodata     relro       bss  overhead     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}"
+  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)
 end

data/lib/elf.rb

@@ -28,15 +28,8 @@ require 'elf/symbol'
 require 'elf/file'
 require 'elf/section'
 
-# We need this quite e lot
-class Integer
-  def hex
-    sprintf "%x", self
-  end
-end
-
 module Elf
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 
   MagicString = "\177ELF"
 

data/lib/elf/file.rb

@@ -230,7 +230,8 @@ module Elf
         # When the section header string table index is set to zero,
         # there is not going to be a string table in the file, this
         # happens usually when the file is a static ELF file built
-        # directly with an assembler.
+        # directly with an assembler, or when it was passed through
+        # the elfkickers' sstrip utility.
         #
         # To handle this specific case, set the @string_table attribute
         # to false, that is distinct from nil, and raise
@@ -316,7 +317,7 @@ module Elf
     def has_section?(sect_idx_or_name)
 
       if sect_idx_or_name.is_a? String and not @string_table.is_a? Elf::Section
-        return false if @string_table == false
+        raise MissingStringTable.new(sect_idx_or_name) if @string_table == false
         raise StringTableNotLoaded.new(sect_idx_or_name) if @string_table.nil?
       end
 

data/lib/elf/symbol.rb

@@ -133,14 +133,18 @@ module Elf
                 end
 
       rescue Elf::Value::OutOfBound => e
-        e.append_message("While processing symbol #{@idx}. Symbol info: 0x#{info.hex}")
+        e.append_message(sprintf("While processing symbol %d. Symbol 'info' value: 0x%x",
+                                 @idx,
+                                 info))
         raise e
       end
 
       begin
         @visibility = Visibility[@other & 0x03]
       rescue Elf::Value::OutOfBound => e
-        e.append_message("While procesing symbol #{@idx}. Symbol other info: 0x#{@other.hex}")
+        e.append_message(sprintf("While procesing symbol %d. Symbol 'other' value: 0x%x",
+                                 @idx,
+                                 other))
         raise e
       end
 
@@ -223,7 +227,7 @@ module Elf
         section = if symbol.section.nil?
                     nil
                   elsif symbol.section.is_a?(Integer)
-                    symbol.section.hex
+                    sprintf("%x", symbol.section)
                   else
                     symbol.section.name
                   end

data/lib/elf/tools.rb

@@ -67,14 +67,9 @@ def self.parse_arguments
     if opt == "--help"
       # check if we're executing from a tarball or the git repository,
       # if so we can't use the system man page.
-      require 'pathname'
-      filepath = Pathname.new($0)
-      localman = filepath.dirname + "../manpages" + filepath.basename.sub(".rb", ".1")
-      if localman.exist?
-        exec("man #{localman.to_s}")
-      else
-        exec("man #{to_s}")
-      end
+      manpage = File.expand_path("../../../manpages/#{to_s}.1", __FILE__)
+      manpage = to_s unless File.exist?(manpage)
+      exec("man #{manpage}")
     end
 
     attrname = opt.gsub(/^--/, "").gsub("-", "_")
@@ -99,6 +94,16 @@ def self.parse_arguments
       raise ArgumentError("wrong number of arguments in callback (#{cb.arity} for #{arg.size})")
     end
   end
+
+  @parsed_options = true
+end
+
+def self.single_target?
+  raise Exception.new("You can't call this until options are parsed") unless @parsed_options
+
+  # We consider having a single target means that we're given exactly
+  # one argument, and that argument is not a targets' list itself.
+  return (ARGV.size == 1 and ARGV[0] !~ /^@/)
 end
 
 def execute(filename)
@@ -178,8 +183,6 @@ end
 
 # Execute the analysis function on all the lines of a file
 def self.execute_on_file(file)
-  @single_target = false
-
   file = $stdin if file == "-"
   file = File.new(file) if file.class == String
 
@@ -197,13 +200,6 @@ def self.main
     parse_arguments
     after_options if respond_to? :after_options
 
-    # We set the @single_target attribute to true if we're given a
-    # single filename as a target, so that tools like elfgrep can
-    # avoid printing again the filename on the output. Since we could
-    # be given a single @-prefixed file to use as a list, we'll reset
-    # @single_target in self.execute_on_file
-    @single_target = (ARGV.size == 1)
-
     if ARGV.size == 0
       execute_on_file($stdin)
     else

data/manpages/cowstats.1.xml

@@ -0,0 +1,234 @@
+<?xml version='1.0'?>
+<!--
+Copyright © 2008-2011, Diego "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
+-->
+<article xmlns="http://docbook.org/ns/docbook"
+         xmlns:xl="http://www.w3.org/1999/xlink"
+         xmlns:xi="http://www.w3.org/2001/XInclude"
+         version="5.0" xml:lang="en">
+  <info>
+    <title>cowstats</title>
+
+    <xi:include parse="xml" href="author.xmli" />
+  </info>
+
+  <section>
+    <title>Reference</title>
+
+    <refentry>
+      <info>
+        <date>October 2008</date>
+        <productname>ruby-elf</productname>
+      </info>
+      <refmeta>
+        <refentrytitle>cowstats</refentrytitle>
+        <manvolnum>1</manvolnum>
+      </refmeta>
+      <refnamediv>
+        <refname>cowstats</refname>
+        <refpurpose>ELF Copy-on-Write analyzer</refpurpose>
+      </refnamediv>
+      <refsynopsisdiv>
+        <cmdsynopsis>
+          <command>cowstats</command>
+          <arg choice="opt"><option>--statistics</option></arg>
+          <arg choice="opt"><option>--total</option></arg>
+          <arg choice="opt"><option>--ignore-cxx</option></arg>
+          <arg choice="opt"><option>--ignore-profiling</option></arg>
+          <arg choice="opt"><option>--ignore-data-rel-ro</option></arg>
+          <arg choice="opt">
+            <option>--sort-by</option>
+            <replaceable>section-column</replaceable>
+          </arg>
+
+          <xi:include href="common.xmli"  xpointer="xpointer(id('filelist.synopsis')/*)" />
+        </cmdsynopsis>
+      </refsynopsisdiv>
+
+      <refsect1>
+        <title>Description</title>
+        <para>
+          <command>cowstats</command> is a script that analyses ELF object files, results of
+          compilation of C, C++ or other languages on an Unix system, and reports about the
+          variables that enter Copy-on-Write sections.
+        </para>
+
+        <para>
+          Static variables (initialised and not) and constant pointers on PIC or PIE enabled object
+          files are emitted in the so-called Copy-on-Write sections, which require copying over
+          pages from the original ELF executable file to a private resident area of memory at
+          runtime.
+        </para>
+
+        <para>
+          <command>cowstats</command> reports the possible symbols that were emitted in
+          Copy-on-Write sections so that they can be looked after to see if they can be made
+          constant and/or removed or reworked.
+        </para>
+      </refsect1>
+
+      <refsect1>
+        <title>Options</title>
+
+        <variablelist>
+          <varlistentry>
+            <term><option>-s</option></term>
+            <term><option>--statistics</option></term>
+            <listitem>
+              <para>
+                Instead of reporting all the variables found in Copy-on-Write sections, only
+                generate a table showing the sie of data in Copy-on-Write sections per each file,
+                divided into <constant>.data</constant>, <constant>.bss</constant> and
+                <constant>.data.rel</constant> (for variables, uninitialised variables, and
+                relocated variables and constants).
+              </para>
+            </listitem>
+          </varlistentry>
+
+          <varlistentry>
+            <term><option>-t</option></term>
+            <term><option>--total</option></term>
+            <listitem>
+              <para>
+                Shows some rough totals for the amount of data in Copy-on-Write sections for the
+                program, assuming all the object files given are linked in the same executable. This
+                will also show a rough page-based total, which bases itself on 4K-sized pages.
+              </para>
+            </listitem>
+          </varlistentry>
+
+          <varlistentry>
+            <term><option>-x</option></term>
+            <term><option>--ignore-cxx</option></term>
+            <listitem>
+              <para>
+                Ignore some C++ entries that could be considered false positives. C++ object files
+                will report as CoW data the vtables and typeinfo objects for C++ classes, since they
+                are actually emitted in Copy-on-Write sections. Since they cannot be moved from
+                thre, this option hides them on the output, to reduce clutter and noise.
+              </para>
+            </listitem>
+          </varlistentry>
+
+          <varlistentry>
+            <term><option>-p</option></term>
+            <term><option>--ignore-profiling</option></term>
+            <listitem>
+              <para>
+                Similarly to C++, also profiling (with <command>gcov</command>) will add some
+                symbols that would be identified as CoW data. Use this option to avoid reporting
+                those symbols.
+              </para>
+            </listitem>
+          </varlistentry>
+
+          <varlistentry>
+            <term><option>-r</option></term>
+            <term><option>--ignore-data-rel-ro</option></term>
+            <listitem>
+              <para>
+                Don't report constants found in the .data.rel.ro section, and consider it as
+                non-relocated. This is helpful to reduce the noise when looking for writable data
+                symbols, or when analysing non-PIC builds.
+              </para>
+            </listitem>
+          </varlistentry>
+
+          <varlistentry>
+            <term>
+              <option>-S</option>
+              <replaceable>section-column</replaceable>
+            </term>
+            <term>
+              <option>--sort-by</option>
+              <replaceable>section-column</replaceable>
+            </term>
+
+            <listitem>
+              <para>
+                Sort the output of <option>--statistics</option> by the given column. Useful when
+                looking for which objects have the most hit for one particular CoW problem. The
+                column can be one of the following section names:
+              </para>
+
+              <itemizedlist>
+                <listitem><para>.bss</para></listitem>
+                <listitem><para>.data</para></listitem>
+                <listitem><para>.data.rel</para></listitem>
+                <listitem><para>.data.rel.ro</para></listitem>
+              </itemizedlist>
+            </listitem>
+          </varlistentry>
+
+          <xi:include href="common.xmli" xpointer="xpointer(id('filelist.option')/*)" />
+
+        </variablelist>
+      </refsect1>
+
+      <refsect1>
+        <title>Bugs</title>
+
+        <para>
+          <command>cowstats</command> is still an experiment, and is
+          not yet entirely complete, there are thus a number of bugs
+          that haven't been discovered or well tested yet.
+        </para>
+
+        <para>
+          A known "bug" or misbehaviour is that <command>cowstats</command> cannot know whether
+          multple object files will be linked together in the same module (executable or shared
+          object) or not. For this reason the output of <option>--total</option> might not be
+          consistent with the runtime behaviour of the module itself.
+        </para>
+
+        <xi:include href="common.xmli" xpointer="xpointer(id('filelist.bugpara')/*)" />
+      </refsect1>
+
+      <refsect1>
+        <title>See Also</title>
+        <para>
+          <citation xl:href="http://blog.flameeyes.eu/">Flameeyes's Weblog</citation>
+          http://blog.flameeyes.eu/
+        </para>
+
+        <para>
+          Related tools:
+
+          <citerefentry>
+            <refentrytitle>rbelf-size</refentrytitle>
+            <manvolnum>1</manvolnum>
+          </citerefentry>,
+
+          <citerefentry>
+            <refentrytitle>objdump</refentrytitle>
+            <manvolnum>1</manvolnum>
+          </citerefentry>.
+        </para>
+      </refsect1>
+    </refentry>
+  </section>
+</article>
+<!--
+    Local Variables:
+    mode: nxml
+    mode: auto-fill
+    mode: flyspell
+    ispell-local-dictionary: "english"
+    fill-column: 100
+    indent-tabs-mode: nil
+    End:
+-->