ruby-elf 1.0.3 → 1.0.4

data/bin/cowstats

@@ -20,245 +20,247 @@
 
 require 'elf/tools'
 
-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 ]
-          ]
+module Elf::Tools
+  class CoWStats < Elf::Tool
 
-def self.before_options
-  @statistics = false
-  @total = false
-  @ignore_cxx = false
-  @ignore_profiling = false
-  @ignore_data_rel_ro = false
+    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 ]
+                  ]
 
-  @results_sorter = Proc.new do |x, y|
-    # 0 is the filename
-    x[0] <=> y[0]
-  end
-  
-  @files_info = {}
-end
+      @statistics = false
+      @total = false
+      @ignore_cxx = false
+      @ignore_profiling = false
+      @ignore_data_rel_ro = false
 
-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
+      @results_sorter = Proc.new do |x, y|
+        # 0 is the filename
+        x[0] <=> y[0]
+      end
 
-def self.after_options
-  if @total
-    @data_total = 0
-    @bss_total = 0
-    @rel_total = 0
-    @relro_total = 0
-  end
-end
+      @files_info = {}
 
-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
+      @data_total = 0
+      @bss_total = 0
+      @rel_total = 0
+      @relro_total = 0
     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
+    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
-      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}"
+        puterror "invalid sort column: #{column}"
+        exit -1
       end
     end
-    
-  end
 
-  return unless (data_size + bss_size + rel_size + relro_size ) > 0
+    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
 
-  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
+        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 == ""
 
-  @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})"
+          # 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
-    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})"
+
+      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
-    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})"
+      
+      if @statistics
+        @files_info[file] = {
+          :data_size => data_size,
+          :bss_size => bss_size,
+          :rel_size => rel_size,
+          :relro_size => relro_size
+        }
+        return
       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
+
+      @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
-  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
+    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
+        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}"
+        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
+        (@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
+      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"
+        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