elftools 1.3.1 → 2.1.0

data/lib/elftools/relocation.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'elftools/constants'
+require 'elftools/util'
+
+module ELFTools
+  # A relocation entry.
+  #
+  # Can be either a REL or RELA relocation.
+  class Relocation
+    attr_reader :header # @return [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela] Rel(a) header.
+    attr_reader :stream # @return [#pos=, #read] Streaming object.
+
+    # Instantiate a {Relocation} object.
+    # @param [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela] header
+    #   The relocation header.
+    # @param [#pos=, #read] stream The streaming object.
+    # @param [Integer] machine
+    #   The machine of the ELF file, which decides what {#type} means and how
+    #   {#header} records it.
+    def initialize(header, stream, machine: nil)
+      @header = header
+      @stream = stream
+      @machine = machine
+    end
+
+    # Which symbol this relocation is against, as an index into the symbol
+    # table.
+    # @return [Integer] The symbol index.
+    def symbol_index
+      sym_and_type.first
+    end
+
+    # What this relocation does, which only means something together with the
+    # machine of the file. {#type_name} names it.
+    # @return [Integer] The relocation type.
+    def type
+      sym_and_type.last
+    end
+
+    # Sets which symbol this relocation is against.
+    # @param [Integer] index The symbol index.
+    # @raise [ArgumentError] If the bits recording it cannot hold it.
+    # @example
+    #   relocation.symbol_index = 3
+    def symbol_index=(index)
+      header.r_info = info_of(Util.fits!(index, index_bits, 'Symbol index'), type)
+    end
+
+    # Sets what this relocation does.
+    # @param [Integer] type The relocation type.
+    # @raise [ArgumentError] If the bits recording it cannot hold it.
+    # @example
+    #   relocation.type = ELFTools::Constants::R::X86_64::R_X86_64_JUMP_SLOT
+    def type=(type)
+      header.r_info = info_of(symbol_index, Util.fits!(type, type_bits, 'Relocation type'))
+    end
+
+    # The name of {#type}.
+    #
+    # Every architecture numbers relocation types on its own, so the name is
+    # only known when the machine of the file is.
+    # @return [String] The name.
+    # @example
+    #   relocation.type_name
+    #   #=> 'R_X86_64_JUMP_SLOT'
+    def type_name
+      Constants::R.mapping(@machine, type)
+    end
+
+    private
+
+    # The +r_info+ recording a symbol index and a type, laid out the way this
+    # file lays it out. The inverse of {#sym_and_type}.
+    # @return [Integer] The +r_info+.
+    def info_of(index, type)
+      return mips64_info_of(index, type) if mips64?
+
+      (index << mask_bit) | type
+    end
+
+    # The +r_info+ as the 64-bit MIPS ABI records it, leaving the bytes the
+    # ABI keeps for itself as they were.
+    # @return [Integer] The +r_info+.
+    def mips64_info_of(index, type)
+      info = header.r_info.to_i
+      return (index << 32) | (info & 0xffff_ff00) | type if header.class.self_endian == :big
+
+      (info & 0x00ff_ffff_0000_0000) | (type << 56) | index
+    end
+
+    # How many bits record a symbol index.
+    # @return [Integer] The number.
+    def index_bits
+      mips64? ? 32 : (header.elf_class - mask_bit)
+    end
+
+    # How many bits record a relocation type.
+    # @return [Integer] The number.
+    def type_bits
+      mips64? ? 8 : mask_bit
+    end
+
+    # What +r_info+ records, i.e. a symbol index and a relocation type. Most
+    # machines split the field in half between the two, one lays it out its
+    # own way.
+    # @return [Array(Integer, Integer)] The symbol index and the type.
+    def sym_and_type
+      return mips64_sym_and_type if mips64?
+
+      [header.r_info >> mask_bit, header.r_info & ((1 << mask_bit) - 1)]
+    end
+
+    # Whether the file records relocations the way the 64-bit MIPS ABI does,
+    # which is the one layout that departs from halving +r_info+.
+    # @return [Boolean] The answer.
+    def mips64?
+      @machine == Constants::EM_MIPS && header.elf_class == 64
+    end
+
+    # Reads +r_info+ as the 64-bit MIPS ABI records it, i.e. a symbol index of
+    # four bytes followed by four bytes the ABI keeps for itself, the last of
+    # which is the type reported here. Those bytes are ordered as the rest of
+    # the file is, which is why the two ends of the field swap places.
+    # @example
+    #   # A big endian file records the symbol index first,
+    #   #   00 00 00 08 | 00    05     18     07
+    #   #   sym         | ssym  type3  type2  type
+    #   0x0000000800051807 #=> [8, 7]
+    #   # a little endian one records the very same relocation as
+    #   0x0718050000000008 #=> [8, 7]
+    # @return [Array(Integer, Integer)] The symbol index and the type.
+    def mips64_sym_and_type
+      info = header.r_info.to_i
+      return [info >> 32, info & 0xff] if header.class.self_endian == :big
+
+      [info & 0xffff_ffff, info >> 56]
+    end
+
+    def mask_bit
+      header.elf_class == 32 ? 8 : 32
+    end
+  end
+end

data/lib/elftools/sections/dynamic_section.rb

@@ -12,6 +12,19 @@ module ELFTools
     class DynamicSection < Section
       include ELFTools::Dynamic
 
+      # Instantiate a {DynamicSection} object.
+      # @param [ELFTools::Structs::ELF_Shdr] header
+      #   See {Section#initialize} for more information.
+      # @param [#pos=, #read] stream
+      #   See {Section#initialize} for more information.
+      # @param [Integer] machine
+      #   The machine of the ELF file, which decides what the entries a tag
+      #   points at mean. This should be +e_machine+ of the ELF header.
+      def initialize(header, stream, machine: nil, **_kwargs)
+        @machine = machine
+        super
+      end
+
       # Get the start address of tags.
       # @return [Integer] Start address of tags.
       def tag_start

data/lib/elftools/sections/relative_relocation_section.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'elftools/relative_relocations'
+require 'elftools/sections/section'
+
+module ELFTools
+  module Sections
+    # Class of the section packing the relocations that only add the load bias.
+    #
+    # This section is usually named .relr.dyn, and records the very relocations
+    # the +DT_RELR+ tag points at.
+    class RelativeRelocationSection < Section
+      # Instantiate a {RelativeRelocationSection} object.
+      # @param [ELFTools::Structs::ELF_Shdr] header
+      #   See {Section#initialize} for more information.
+      # @param [#pos=, #read] stream
+      #   See {Section#initialize} for more information.
+      # @param [Integer] machine
+      #   The machine of the ELF file, which decides what these relocations
+      #   are of. This should be +e_machine+ of the ELF header.
+      def initialize(header, stream, machine: nil, **_kwargs)
+        @machine = machine
+        super
+      end
+
+      # The relocations the section packs.
+      # @return [Array<ELFTools::Relocation>]
+      #   The relocations, in the ascending order the section records them.
+      # @example
+      #   section.relocations.map(&:type_name).uniq
+      #   #=> ['R_X86_64_RELATIVE']
+      def relocations
+        @relocations ||= RelativeRelocations.new(
+          stream, header.sh_offset.to_i...(header.sh_offset.to_i + header.sh_size.to_i),
+          elf_class: header.elf_class, endian: header.class.self_endian, machine: @machine
+        ).to_a
+      end
+
+      # How many relocations the section packs.
+      # @return [Integer] The number.
+      def num_relocations
+        relocations.size
+      end
+    end
+  end
+end

data/lib/elftools/sections/relocation_section.rb

@@ -1,14 +1,29 @@
 # frozen_string_literal: true
 
 require 'elftools/constants'
+require 'elftools/relocation'
 require 'elftools/sections/section'
 require 'elftools/structs'
 
 module ELFTools
   module Sections
-    # Class of note section.
-    # Note section records notes
+    # Class of relocation section.
+    # Usually for sections .rel.* and .rela.*,
+    # which record relocations in ELF file.
     class RelocationSection < Section
+      # Instantiate a {RelocationSection} object.
+      # @param [ELFTools::Structs::ELF_Shdr] header
+      #   See {Section#initialize} for more information.
+      # @param [#pos=, #read] stream
+      #   See {Section#initialize} for more information.
+      # @param [Integer] machine
+      #   The machine of the ELF file, which decides what a relocation type
+      #   means. This should be +e_machine+ of the ELF header.
+      def initialize(header, stream, machine: nil, **_kwargs)
+        @machine = machine
+        super
+      end
+
       # Is this relocation a RELA or REL type.
       # @return [Boolean] If is RELA.
       def rela?
@@ -42,19 +57,22 @@ module ELFTools
       # @return [Enumerator<ELFTools::Relocation>, Array<ELFTools::Relocation>]
       #   If block is not given, an enumerator will be returned.
       #   Otherwise, the whole relocations will be returned.
-      def each_relocations(&block)
-        return enum_for(:each_relocations) unless block_given?
+      def each_relocation(&block)
+        return enum_for(:each_relocation) unless block_given?
 
         Array.new(num_relocations) do |i|
           relocation_at(i).tap(&block)
         end
       end
 
+      # The name this used to go by, kept so that it keeps working.
+      alias each_relocations each_relocation
+
       # Simply use {#relocations} to get all relocations.
       # @return [Array<ELFTools::Relocation>]
       #   Whole relocations.
       def relocations
-        each_relocations.to_a
+        each_relocation.to_a
       end
 
       private
@@ -65,45 +83,8 @@ module ELFTools
         rel = klass.new(endian: header.class.self_endian, offset: stream.pos)
         rel.elf_class = header.elf_class
         rel.read(stream)
-        Relocation.new(rel, stream)
+        Relocation.new(rel, stream, machine: @machine)
       end
     end
   end
-
-  # A relocation entry.
-  #
-  # Can be either a REL or RELA relocation.
-  # XXX: move this to an independent file?
-  class Relocation
-    attr_reader :header # @return [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela] Rel(a) header.
-    attr_reader :stream # @return [#pos=, #read] Streaming object.
-
-    # Instantiate a {Relocation} object.
-    def initialize(header, stream)
-      @header = header
-      @stream = stream
-    end
-
-    # +r_info+ contains sym and type, use two methods
-    # to access them easier.
-    # @return [Integer] sym infor.
-    def r_info_sym
-      header.r_info >> mask_bit
-    end
-    alias symbol_index r_info_sym
-
-    # +r_info+ contains sym and type, use two methods
-    # to access them easier.
-    # @return [Integer] type infor.
-    def r_info_type
-      header.r_info & ((1 << mask_bit) - 1)
-    end
-    alias type r_info_type
-
-    private
-
-    def mask_bit
-      header.elf_class == 32 ? 8 : 32
-    end
-  end
 end

data/lib/elftools/sections/section.rb

@@ -13,16 +13,16 @@ module ELFTools
       #   The section header object.
       # @param [#pos=, #read] stream
       #   The streaming object for further dump.
-      # @param [ELFTools::Sections::StrTabSection, Proc] strtab
+      # @param [ELFTools::Sections::StrTabSection, Proc] section_name_table
       #   The string table object. For fetching section names.
       #   If +Proc+ if given, it will call at the first
       #   time access +#name+.
       # @param [Method] offset_from_vma
       #   The method to get offset of file, given virtual memory address.
-      def initialize(header, stream, offset_from_vma: nil, strtab: nil, **_kwargs)
+      def initialize(header, stream, offset_from_vma: nil, section_name_table: nil, **_kwargs)
         @header = header
         @stream = stream
-        @strtab = strtab
+        @section_name_table = section_name_table
         @offset_from_vma = offset_from_vma
       end
 
@@ -36,7 +36,7 @@ module ELFTools
       # Get name of this section.
       # @return [String] The name.
       def name
-        @name ||= @strtab.call.name_at(header.sh_name)
+        @name ||= @section_name_table.call.name_at(header.sh_name)
       end
 
       # Fetch data of this section.
@@ -46,6 +46,37 @@ module ELFTools
         stream.read(header.sh_size)
       end
 
+      # Is this section written to while the file runs?
+      # @return [Boolean] True or false.
+      # @example
+      #   elf.section_by_name('.data').writable?
+      #   #=> true
+      def writable?
+        header.sh_flags.allbits?(Constants::SHF_WRITE)
+      end
+
+      # Is this section executed?
+      # @return [Boolean] True or false.
+      # @example
+      #   elf.section_by_name('.text').executable?
+      #   #=> true
+      def executable?
+        header.sh_flags.allbits?(Constants::SHF_EXECINSTR)
+      end
+
+      # Does this section take memory while the file runs?
+      #
+      # The ones that do are what a file is loaded by, the rest being what is
+      # recorded about it, its symbol names and its debugging information
+      # among them.
+      # @return [Boolean] True or false.
+      # @example
+      #   elf.section_by_name('.symtab').allocated?
+      #   #=> false
+      def allocated?
+        header.sh_flags.allbits?(Constants::SHF_ALLOC)
+      end
+
       # Is this a null section?
       # @return [Boolean] No it's not.
       def null?

data/lib/elftools/sections/sections.rb

@@ -7,9 +7,13 @@ require 'elftools/sections/section'
 require 'elftools/sections/dynamic_section'
 require 'elftools/sections/note_section'
 require 'elftools/sections/null_section'
+require 'elftools/sections/relative_relocation_section'
 require 'elftools/sections/relocation_section'
 require 'elftools/sections/str_tab_section'
 require 'elftools/sections/sym_tab_section'
+require 'elftools/sections/version_definition_section'
+require 'elftools/sections/version_need_section'
+require 'elftools/sections/version_section'
 
 module ELFTools
   # Defines different types of sections in this module.
@@ -27,6 +31,10 @@ module ELFTools
                 when Constants::SHT_NULL then NullSection
                 when Constants::SHT_NOTE then NoteSection
                 when Constants::SHT_RELA, Constants::SHT_REL then RelocationSection
+                when Constants::SHT_RELR then RelativeRelocationSection
+                when Constants::SHT_GNU_versym then VersionSection
+                when Constants::SHT_GNU_verneed then VersionNeedSection
+                when Constants::SHT_GNU_verdef then VersionDefinitionSection
                 when Constants::SHT_STRTAB then StrTabSection
                 when Constants::SHT_SYMTAB, Constants::SHT_DYNSYM then SymTabSection
                 else Section

data/lib/elftools/sections/sym_tab_section.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'elftools/sections/section'
+require 'elftools/sections/symbol'
+require 'elftools/version_tables'
 
 module ELFTools
   module Sections
@@ -15,11 +17,16 @@ module ELFTools
       #   See {Section#initialize} for more information.
       # @param [#pos=, #read] stream
       #   See {Section#initialize} for more information.
-      # @param [Proc] section_at
-      #   The method for fetching other sections by index.
-      #   This lambda should be {ELFTools::ELFFile#section_at}.
-      def initialize(header, stream, section_at: nil, **_kwargs)
-        @section_at = section_at
+      # @param [Proc] sections
+      #   The method for fetching the sections, which is where the names and
+      #   the versions of these symbols are recorded. This lambda should be
+      #   {ELFTools::ELFFile#sections}.
+      # @param [Integer] machine
+      #   The machine of the ELF file, which decides what the fields of a
+      #   symbol mean. This should be +e_machine+ of the ELF header.
+      def initialize(header, stream, sections: nil, machine: nil, **_kwargs)
+        @sections = sections
+        @machine = machine
         # For faster #symbol_by_name
         super
       end
@@ -56,19 +63,22 @@ module ELFTools
       # @return [Enumerator<ELFTools::Sections::Symbol>, Array<ELFTools::Sections::Symbol>]
       #   If block is not given, an enumerator will be returned.
       #   Otherwise return array of symbols.
-      def each_symbols(&block)
-        return enum_for(:each_symbols) unless block_given?
+      def each_symbol(&block)
+        return enum_for(:each_symbol) unless block_given?
 
         Array.new(num_symbols) do |i|
           symbol_at(i).tap(&block)
         end
       end
 
+      # The name this used to go by, kept so that it keeps working.
+      alias each_symbols each_symbol
+
       # Simply use {#symbols} to get all symbols.
       # @return [Array<ELFTools::Sections::Symbol>]
       #   The whole symbols.
       def symbols
-        each_symbols.to_a
+        each_symbol.to_a
       end
 
       # Get symbol by its name.
@@ -76,14 +86,14 @@ module ELFTools
       #   The name of symbol.
       # @return [ELFTools::Sections::Symbol] Desired symbol.
       def symbol_by_name(name)
-        each_symbols.find { |symbol| symbol.name == name }
+        each_symbol.find { |symbol| symbol.name == name }
       end
 
       # Return the symbol string section.
       # Lazy loaded.
       # @return [ELFTools::Sections::StrTabSection] The string table section.
       def symstr
-        @symstr ||= @section_at.call(header.sh_link)
+        @symstr ||= @sections.call[header.sh_link]
       end
 
       private
@@ -92,35 +102,37 @@ module ELFTools
         stream.pos = header.sh_offset + n * header.sh_entsize
         sym = Structs::ELF_sym[header.elf_class].new(endian: header.class.self_endian, offset: stream.pos)
         sym.read(stream)
-        Symbol.new(sym, stream, symstr: method(:symstr))
+        Symbol.new(sym, stream, symstr: method(:symstr), machine: @machine, version: -> { version_at(n) })
       end
-    end
 
-    # Class of symbol.
-    #
-    # XXX: Should this class be defined in an independent file?
-    class Symbol
-      attr_reader :header # @return [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym] Section header.
-      attr_reader :stream # @return [#pos=, #read] Streaming object.
-
-      # Instantiate a {ELFTools::Sections::Symbol} object.
-      # @param [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym] header
-      #   The symbol header.
-      # @param [#pos=, #read] stream The streaming object.
-      # @param [ELFTools::Sections::StrTabSection, Proc] symstr
-      #   The symbol string section.
-      #   If +Proc+ is given, it will be called at the first time
-      #   access {Symbol#name}.
-      def initialize(header, stream, symstr: nil)
-        @header = header
-        @stream = stream
-        @symstr = symstr
+      # The version the +n+-th symbol binds to.
+      # @return [ELFTools::VersionTables::Version, nil]
+      #   The version, +nil+ unless this is the table a file is loaded by and
+      #   the file records versions at all.
+      def version_at(n)
+        return if versions.nil?
+
+        VersionTables.version(versions.version_at(n), versions_by_index)
+      end
+
+      # The section recording which version each of these symbols binds to,
+      # which is the one naming this table.
+      # @return [ELFTools::Sections::VersionSection, nil] The section.
+      def versions
+        return @versions if defined?(@versions)
+
+        @versions = @sections&.call&.find do |sec|
+          sec.is_a?(VersionSection) && @sections.call[sec.header.sh_link].equal?(self)
+        end
       end
 
-      # Return the symbol name.
-      # @return [String] The name.
-      def name
-        @name ||= @symstr.call.name_at(header.st_name)
+      # The name each index the symbols record names.
+      # @return [Hash{Integer => String}] The names.
+      def versions_by_index
+        @versions_by_index ||= VersionTables.names(
+          @sections.call.grep(VersionNeedSection).flat_map(&:requirements),
+          @sections.call.grep(VersionDefinitionSection).flat_map(&:definitions)
+        )
       end
     end
   end