ruby-elf 1.0.7 → 1.0.8

data/bin/rbelf-read

@@ -1,146 +0,0 @@
-#!/usr/bin/env ruby
-# -*- mode: ruby; coding: utf-8 -*-
-# Copyright © 2008-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
-
-# proof-of-concept reimplementation of readelf(1)
-
-require 'elf/tools'
-
-module Elf::Tools
-  class ReadElf < Elf::Tool
-    def self.initialize
-      super
-      @options |= [
-                   ["--all", "-a", GetoptLong::NO_ARGUMENT],
-                   ["--file-header", "-h", GetoptLong::NO_ARGUMENT],
-                   ["--section-headers", "-S", GetoptLong::NO_ARGUMENT],
-                   ["--dynamic", "-d", GetoptLong::NO_ARGUMENT],
-                  ]
-    end
-
-    def self.all_cb
-      @section_headers = true
-      @dynamic = true
-    end
-
-    def self.after_options
-    end
-
-    def self.analysis(file)
-      elf = Elf::File.open(file)
-
-      @output_mutex.synchronize {
-        printf("\nFile: %s\n", file) if @targets.size != 1
-        read_file_header(elf) if @file_header
-        read_sections(elf) if @section_headers
-        read_dynamic(elf) if @dynamic
-      }
-    end
-
-    def self.read_sections(elf)
-      printf("There are %d section headers, starting at offset 0x%x:\n\nSection Headers:\n",
-             elf.sections, elf.shoff)
-
-      printf("[Nr] Name                    Type          Addr             Off      Size     ES Flags Lk Inf Al\n")
-
-      elf.each_section do |section|
-        printf("[%2d] %s %s %0#{elf.address_print_size}x %08x %08x %2d %s %2d %3d %2d\n",
-               section.index,
-               section.name.ljust(23),
-               section.type.mnemonic.upcase.ljust(13),
-               section.addr, section.offset, section.size, section.entsize,
-               section.flags_s.ljust(5), section.link.to_i, section.info, section.addralign)
-      end
-
-      printf("\n")
-    end
-
-    def self.read_dynamic(elf)
-      dynsection = elf[".dynamic"]
-
-      if dynsection.nil?
-        printf("\nThere is no dynamic section in this file.\n")
-        return
-      end
-
-      printf("\nDynamic section at offset 0x%x contains %d entries:\n",
-             dynsection.offset, dynsection.size)
-      printf("  Tag                Type                 Name/Value\n")
-
-      dynsection.each_entry do |entry|
-        case entry.type
-        when Elf::Dynamic::Type::Needed
-          val = "Shared library: [#{entry.parsed}]"
-        when Elf::Dynamic::Type::Auxiliary
-          val = "Auxiliary library: [#{entry.parsed}]"
-        when Elf::Dynamic::Type::SoName
-          val = "Library soname: [#{entry.parsed}]"
-        when Elf::Dynamic::Type::StrSz, Elf::Dynamic::Type::SymEnt,
-          Elf::Dynamic::Type::PltRelSz, Elf::Dynamic::Type::RelASz,
-          Elf::Dynamic::Type::RelAEnt
-
-          val = "#{entry.value} (bytes)"
-        when Elf::Dynamic::Type::VerDefNum, Elf::Dynamic::Type::VerNeedNum, Elf::Dynamic::Type::RelACount
-          val = entry.value
-        when Elf::Dynamic::Type::GNUPrelinked
-          val = entry.parsed.getutc.strftime('%Y-%m-%dT%H:%M:%S')
-        else
-          val = sprintf("0x%x", entry.value)
-        end
-
-        printf(" 0x%016x %-20s %s\n", entry.type.to_i, "(#{entry.type.to_s})", val)
-
-        break if entry.type == Elf::Dynamic::Type::Null
-      end
-    end
-
-    def self.put_header(key, value)
-      printf "  %s %s\n", "#{key}:".ljust(34), value
-    end
-
-    def self.read_file_header(elf)
-      puts "ELF Header:"
-      # put this verbatim, since it never should change
-      puts "  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00"
-
-      put_header("Class", case elf.elf_class
-                          when Elf::Class::Elf32 then "ELF32"
-                          when Elf::Class::Elf64 then "ELF64"
-                          end)
-      put_header("Data", "2's complement, " + case elf.data_encoding
-                                              when Elf::DataEncoding::Lsb then 'little endian'
-                                              when Elf::DataEncoding::Msb then 'big endian'
-                                              end)
-      put_header("Ident Version", elf.version)
-      put_header("OS/ABI", elf.abi)
-      put_header("ABI Version", elf.abi_version)
-      put_header("Type", "#{elf.type.mnemonic.upcase} (#{elf.type})")
-      put_header("Machine", elf.machine)
-      put_header("Version", elf.version)
-      put_header("Entry point address", sprintf("0x%x", elf.entry_address))
-      put_header("Start of program headers", "#{elf.phoff} (bytes into file)")
-      put_header("Start of section headers", "#{elf.shoff} (bytes into file)")
-      put_header("Flags", sprintf("0x%x", elf.flags))
-      put_header("Size of this header", "#{elf.ehsize} (bytes)")
-      put_header("Size of program headers", "#{elf.phentsize} (bytes)")
-      put_header("Number of program headers", elf.phnum);
-      put_header("Size of section headers", "#{elf.shentsize} (bytes)")
-      put_header("Number of section headers", elf.shnum)
-      put_header("Section header string table index", elf.shstrndx)
-    end
-  end
-end

data/bin/rbelf-size

@@ -1,184 +0,0 @@
-#!/usr/bin/env ruby
-# -*- mode: ruby; coding: utf-8 -*-
-# Copyright © 2008-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
-
-# replacement for size(1) utility that takes into consideration .rodata sections
-
-require 'elf/tools'
-
-module Elf::Tools
-  class Size < Elf::Tool
-    def self.initialize
-      super
-      @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],
-                   # Show differences between the first parameter and
-                   # the following.
-                   ["--differential", "-D", GetoptLong::NO_ARGUMENT],
-                  ]
-
-      @relocation_stats = false
-    end
-
-    def self.after_options
-      # to properly handle the differential size count, we have to
-      # process all the files in sequence; this means that we cannot
-      # use multithreaded scan here.
-      @execution_threads = nil if @differential
-
-      @processing = []
-
-      results_formats = {:filename => "  %s\n"}
-
-      if @relocation_stats
-        @processing << :relocation_stats
-        @processing << :convert_ratio if @decibel
-        @results_fields = [ :shared, :private, :relocated, :ratio, :filename ]
-      else
-        @processing << :count_allocated
-        @results_fields = [ :exec, :data, :rodata, :relro, :bss, :overhead, :allocated, :filename ]
-      end
-
-      @processing << :apply_differential if @differential
-      @processing << :print_results
-      @processing << :differential_format if @differential
-
-      printf( (@results_fields.collect { |field| results_formats[field] || "% 12s" }).join(" "),
-              *@results_fields)
-
-      results_formats[:ratio] = "%12.2f" # special format only for printing
-
-      @format = (@results_fields.collect { |field| results_formats[field] || "% 12d" }).join(" ")
-    end
-
-    def self.analysis(file)
-      Elf::File.open(file) do |elf|
-        results = {
-          :exec => 0,
-          :data => 0,
-          :rodata => 0,
-          :relro => 0,
-          :bss => 0,
-          :overhead => 0,
-          :allocated => 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
-            # .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)
-            # 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
-            # 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
-
-          results[sectype] += section.size unless sectype.nil?
-        end
-
-        results[:filename] = file
-
-        @processing.each do |process|
-          method(process).call(results)
-        end
-      end
-    end
-
-    def self.count_allocated(results)
-      results[:allocated] = results.values.inject { |sum, val|
-        sum = val.is_a?(String) ? sum : (sum+val)
-      }
-    end
-
-    def self.apply_differential(results)
-      if @first_results.nil?
-        (@first_results = results.dup).delete(:filename)
-        return
-      end
-
-      @results_fields.each do |field|
-        results[field] = results[field] - @first_results[field] rescue nil
-      end
-    end
-
-    def self.differential_format(results)
-      @format.gsub!(/%( [0-9]+d)/, '%+\1')
-      @processing.delete(:differential_format)
-    end
-
-    def self.relocation_stats(results)
-      results[:shared]    = results[:exec] + results[:rodata]
-      results[:private]   = results[:data] + results[:bss]
-      results[:relocated] = results[:relro]
-
-      results[:ratio]     = results[:shared].to_f/results[:relocated]
-    end
-
-    def self.convert_ratio(results)
-      results[:ratio] = 10 * Math::log10(results[:ratio])
-    end
-
-    def self.print_results(results)
-      printf(@format,
-             *(@results_fields.collect { |field| results[field] }))
-    end
-  end
-end

data/bin/verify-lfs

@@ -1,125 +0,0 @@
-#!/usr/bin/env ruby
-# -*- mode: ruby; coding: utf-8 -*-
-# Copyright © 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
-
-# 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'
-
-module Elf::Tools
-  class VerifyLFS < Elf::Tool
-    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"
-                      ]
-
-    SymbolRegex32 = Regexp.union(SymbolNamesList.collect { |sym| /^#{sym}$/ })
-    SymbolRegex64 = Regexp.union(SymbolNamesList.collect { |sym| /^#{sym}64$/ })
-
-    def self.initialize
-      super
-      @options |= [
-                   # Scan only object files (rather than non-object files)
-                   ["--objects", "-o", GetoptLong::NO_ARGUMENT]
-                  ]
-    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 =~ SymbolRegex32)
-          use_stat64 ||= (symbol.to_s =~ SymbolRegex64)
-
-          # 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
-  end
-end