elftools 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0213b757f8eab7a9a4806fdca95e68e8ac3f64fc226c69cf272d071def187172
-  data.tar.gz: 891db5a15bc0b44c09d0135a0c5b8f95633fa49b07d18e8e2a563f8384842f90
+  metadata.gz: cbbd11ec3b95d867ab34551c14f1a0a53c3c5e2ebb539d226b16378873a0f74a
+  data.tar.gz: 05301ad23c8d366858d57f58cccf4a3274608a036de07e629e85075b4e1babd5
 SHA512:
-  metadata.gz: 7a10ccb7a4d7b4b7c9bdc30aca01a330848ea0c9aa9a34b310e315acd5823312f413b84b9ddc72c479d3363494960abfd41b10857a34c6402fec2958ee039e64
-  data.tar.gz: 57902a64f1450d229bff599d7a3fac08f3f8e1f80490924a2d1b959404e90aa68880d92437a5d1a55e2d19c88ea8028c954fa209c51f6037117b4f1057e1eabb
+  metadata.gz: 2e96723b2a63f7f6692cc6777bd64bd3b5e3aae7321a09da3a9098e26a4a95162bc892a2933088bc6fef89f14cb72269434e71c32bc2551f5b252105b09d6aa8
+  data.tar.gz: b177302e11ea50108f582dc4f70651136dcc5a15e2363856f2cfc453fbd2979eb202520a40468b4349af12e0dc1c84960b4972548c360bf902729e3acb98f456

data/lib/elftools/constants.rb

@@ -466,6 +466,15 @@ module ELFTools
     end
     include SHN
 
+    # The escape value the ELF header records where it cannot hold a count of
+    # the program headers, which is then recorded in the first section header.
+    module PN
+      extend Naming
+
+      PN_XNUM = 0xffff # the number of program headers is too large for the header to hold
+    end
+    include PN
+
     # Section flag mask types, records in +sh_flag+.
     module SHF
       SHF_WRITE = (1 << 0) # Writable

data/lib/elftools/dynamic/symbols.rb

@@ -29,11 +29,11 @@ module ELFTools
         return if n.negative?
 
         @symbol_at_map ||= {}
-        @symbol_at_map[n] ||= begin
-          sym = read_struct(Structs::ELF_sym[header.elf_class], sym_offset + (n * sym_entsize))
-          Sections::Symbol.new(sym, stream, symstr: method(:string_table), machine: @machine,
-                                            version: -> { version_at(n) })
-        end
+        @symbol_at_map[n] ||= Sections::Symbol.new(
+          Structs::Fields.new(Structs::ELF_sym[header.elf_class], stream, sym_offset + (n * sym_entsize),
+                              elf_class: header.elf_class, endian: endian),
+          stream, symstr: string_table_reader, machine: @machine, version: -> { version_at(n) }
+        )
       end
 
       # How many symbols the tags reach.
@@ -154,7 +154,14 @@ module ELFTools
       # has no way of disagreeing with.
       # @return [Integer] The number.
       def sym_entsize
-        @sym_entsize ||= struct(Structs::ELF_sym[header.elf_class]).num_bytes
+        @sym_entsize ||= Structs::ELF_sym[header.elf_class].num_bytes(elf_class: header.elf_class, endian: endian)
+      end
+
+      # What reads the table these symbols are named in, kept so that reading
+      # a table of them does not make one for every symbol.
+      # @return [Method] The method.
+      def string_table_reader
+        @string_table_reader ||= method(:string_table)
       end
 
       # Get the +DT_SYMTAB+'s +d_val+ offset related to file.

data/lib/elftools/dynamic/tag.rb

@@ -1,25 +1,47 @@
 # frozen_string_literal: true
 
 require 'elftools/constants'
+require 'elftools/structs'
 
 module ELFTools
   module Dynamic
     # A tag class.
     class Tag
-      attr_reader :header # @return [ELFTools::Structs::ELF_Dyn] The dynamic tag header.
       attr_reader :stream # @return [#pos=, #read] Streaming object.
 
       # Instantiate a {ELFTools::Dynamic::Tag} object.
-      # @param [ELF_Dyn] header The dynamic tag header.
+      # @param [ELFTools::Structs::ELF_Dyn, ELFTools::Structs::Fields] header
+      #   The dynamic tag header, or what the file records in one.
+      #   {ELFTools::Structs::Fields} answers what the tag records until
+      #   something asks for {#header} itself, which builds the structure then.
       # @param [#pos=, #read] stream Streaming object.
       # @param [ELFTools::Dynamic::StringTable] strtab
       #   The string table the names of tags are recorded in.
       def initialize(header, stream, strtab)
-        @header = header
+        @fields = header.is_a?(Structs::Fields) ? header : Structs::Fields.of(header)
         @stream = stream
         @strtab = strtab
       end
 
+      # The structure the file records this tag in.
+      #
+      # One is built here for a tag read without it, which is what assigning to
+      # a field of one needs and what {ELFTools::ELFFile#patches} reports the
+      # changes of.
+      # @return [ELFTools::Structs::ELF_Dyn] The structure.
+      def header
+        @fields.struct
+      end
+
+      # What kind of tag this is, which {ELFTools::Constants::DT} names.
+      # @return [Integer] The type.
+      # @example
+      #   dynamic.tag_by_type(:needed).type == ELFTools::Constants::DT_NEEDED
+      #   #=> true
+      def type
+        @fields[:d_tag]
+      end
+
       # Some dynamic have name.
       TYPE_WITH_NAME = [Constants::DT_NEEDED,
                         Constants::DT_SONAME,
@@ -40,7 +62,7 @@ module ELFTools
       #   dynamic.tag_by_type(:needed).value
       #   #=> 'libc.so.6'
       def value
-        name || header.d_val.to_i
+        name || @fields[:d_val]
       end
 
       # Is this tag has a name?
@@ -48,7 +70,7 @@ module ELFTools
       # The criteria here is if this tag's type is in {TYPE_WITH_NAME}.
       # @return [Boolean] Is this tag has a name.
       def name?
-        TYPE_WITH_NAME.include?(header.d_tag)
+        TYPE_WITH_NAME.include?(type)
       end
 
       # Return the name of this tag.
@@ -59,7 +81,7 @@ module ELFTools
       def name
         return nil unless name?
 
-        @strtab.name_at(header.d_val.to_i)
+        @strtab.name_at(@fields[:d_val])
       end
     end
   end

data/lib/elftools/dynamic.rb

@@ -38,7 +38,7 @@ module ELFTools
       0.step do |i|
         tag = tag_at(i).tap(&block)
         arr << tag
-        break if tag.header.d_tag == ELFTools::Constants::DT_NULL
+        break if tag.type == ELFTools::Constants::DT_NULL
       end
       arr
     end
@@ -79,7 +79,7 @@ module ELFTools
     #   #=> #<ELFTools::Dynamic::Tag:0x0055d3d2d91b28 @header={:d_tag=>3, :d_val=>6295552}>
     def tag_by_type(type)
       type = Util.to_constant(Constants::DT, type)
-      each_tag.find { |tag| tag.header.d_tag == type }
+      each_tag.find { |tag| tag.type == type }
     end
 
     # Get tags of specific type.
@@ -91,7 +91,7 @@ module ELFTools
     # @see #tag_by_type
     def tags_by_type(type)
       type = Util.to_constant(Constants::DT, type)
-      each_tag.select { |tag| tag.header.d_tag == type }
+      each_tag.select { |tag| tag.type == type }
     end
 
     # Get the +n+-th tag.
@@ -112,11 +112,10 @@ module ELFTools
       @tag_at_map ||= {}
       return @tag_at_map[n] if @tag_at_map[n]
 
-      dyn = Structs::ELF_Dyn.new(endian:)
-      dyn.elf_class = header.elf_class
-      stream.pos = tag_start + n * dyn.num_bytes
-      dyn.offset = stream.pos
-      @tag_at_map[n] = Tag.new(dyn.read(stream), stream, string_table)
+      elf_class = header.elf_class
+      offset = tag_start + (n * Structs::ELF_Dyn.num_bytes(elf_class: elf_class, endian: endian))
+      fields = Structs::Fields.new(Structs::ELF_Dyn, stream, offset, elf_class: elf_class, endian: endian)
+      @tag_at_map[n] = Tag.new(fields, stream, string_table)
     end
 
     # The relocations the tags point at.
@@ -176,32 +175,14 @@ module ELFTools
       # An entry takes what its structure takes. DT_RELAENT and DT_RELENT
       # record the same number, which a file has no way of disagreeing with
       # and every file here agrees with.
-      entsize = struct(klass).num_bytes
+      elf_class = header.elf_class
+      entsize = klass.num_bytes(elf_class: elf_class, endian: endian)
       Array.new(size.header.d_val.to_i / entsize) do |i|
-        Relocation.new(read_struct(klass, offset + (i * entsize)), stream, machine: @machine)
+        fields = Structs::Fields.new(klass, stream, offset + (i * entsize), elf_class: elf_class, endian: endian)
+        Relocation.new(fields, stream, machine: @machine)
       end
     end
 
-    # A structure of the endianness and the class the file records it in.
-    # @param [Class] klass The structure class.
-    # @return [ELFTools::Structs::ELFStruct] The structure, before it is read.
-    def struct(klass)
-      struct = klass.new(endian:)
-      struct.elf_class = header.elf_class
-      struct
-    end
-
-    # Reads a structure the file records at a file offset.
-    # @param [Class] klass The structure class.
-    # @param [Integer] offset The file offset.
-    # @return [ELFTools::Structs::ELFStruct] The structure.
-    def read_struct(klass, offset)
-      struct = struct(klass)
-      struct.offset = offset
-      stream.pos = offset
-      struct.read(stream)
-    end
-
     # The file offset the address a tag records points at.
     # @param [ELFTools::Dynamic::Tag] tag The tag.
     # @return [Integer] The file offset.
@@ -210,7 +191,7 @@ module ELFTools
     def offset_of(tag)
       vma = tag.header.d_val.to_i
       @offset_from_vma.call(vma) ||
-        raise(ELFError, format('Invalid %s address 0x%x', Constants::DT.mapping(@machine, tag.header.d_tag.to_i), vma))
+        raise(ELFError, format('Invalid %s address 0x%x', Constants::DT.mapping(@machine, tag.type), vma))
     end
 
     # The names the tags and the symbols point at.

data/lib/elftools/elf_file.rb

@@ -105,12 +105,19 @@ module ELFTools
     #========= method about sections
 
     # Number of sections in this file.
+    #
+    # A file with more sections than the ELF header can count records a zero
+    # there and states the number in the first section header instead, which a
+    # file with no section headers at all records as well.
     # @return [Integer] The desired number.
     # @example
     #   elf.num_sections
     #   #=> 29
     def num_sections
-      header.e_shnum
+      count = header.e_shnum.to_i
+      return count unless count.zero? && !header.e_shoff.to_i.zero?
+
+      first_section_header.sh_size.to_i
     end
 
     # Acquire the section named as +name+.
@@ -197,15 +204,25 @@ module ELFTools
     #   elf.section_name_table.name
     #   #=> '.shstrtab'
     def section_name_table
-      section_at(header.e_shstrndx)
+      index = header.e_shstrndx.to_i
+      # An index too large for the ELF header is stated in the first section
+      # header instead.
+      index = first_section_header.sh_link.to_i if index == Constants::SHN_XINDEX
+      section_at(index)
     end
 
     #========= method about segments
 
     # Number of segments in this file.
+    #
+    # A file with more segments than the ELF header can count states the number
+    # in the first section header instead, as it does for the sections.
     # @return [Integer] The desited number.
     def num_segments
-      header.e_phnum
+      count = header.e_phnum.to_i
+      return count unless count == Constants::PN_XNUM
+
+      first_section_header.sh_info.to_i
     end
 
     # Iterate all segments.
@@ -373,15 +390,35 @@ module ELFTools
 
     # bad idea..
     def loaded_headers
-      explore = lambda do |obj|
-        return obj if obj.is_a?(::ELFTools::Structs::ELFStruct)
-        return obj.map(&explore) if obj.is_a?(Array)
+      # By identity, so that a graph that reaches the same thing by many paths,
+      # or leads round in circles, is walked once rather than over and over.
+      headers_in(self, {}.compare_by_identity).flatten
+    end
 
-        obj.instance_variables.map do |s|
-          explore.call(obj.instance_variable_get(s))
-        end
-      end
-      explore.call(self).flatten
+    # The structures reachable from an object, whatever holds them.
+    # @param [Object] obj The object.
+    # @param [Hash] seen What has been reached already.
+    # @return [Array] The structures, nested.
+    def headers_in(obj, seen)
+      # A class is not one of the things a file records.
+      return [] if seen[obj] || obj.is_a?(Module)
+
+      seen[obj] = true
+      return obj if obj.is_a?(::ELFTools::Structs::ELFStruct)
+
+      held_by(obj).map { |held| headers_in(held, seen) }
+    end
+
+    # What an object holds, which a walk of it goes on to.
+    # @param [Object] obj The object.
+    # @return [Enumerable] What it holds.
+    def held_by(obj)
+      return obj if obj.is_a?(Array)
+      # A hash is held by its values, which is where the tags and the symbols
+      # read through the tags are remembered.
+      return obj.each_value if obj.is_a?(Hash)
+
+      obj.instance_variables.map { |name| obj.instance_variable_get(name) }
     end
 
     def identify
@@ -404,6 +441,18 @@ module ELFTools
       raise ELFDataError, format('Invalid EI_DATA "\x%02x"', ei_data) if endian.nil?
     end
 
+    # The first section header, which is where a file too large for the counts
+    # the ELF header records states them.
+    # @return [ELFTools::Structs::ELF_Shdr] The header.
+    def first_section_header
+      @first_section_header ||= begin
+        stream.pos = header.e_shoff.to_i
+        shdr = Structs::ELF_Shdr.new(endian:, offset: stream.pos)
+        shdr.elf_class = elf_class
+        shdr.read(stream)
+      end
+    end
+
     def create_section(n)
       stream.pos = header.e_shoff + n * header.e_shentsize
       shdr = Structs::ELF_Shdr.new(endian:, offset: stream.pos)

data/lib/elftools/relative_relocations.rb

@@ -39,10 +39,9 @@ module ELFTools
     def to_a
       type = Constants::R.relative(@machine)
       addresses.map do |address, from|
-        rel = Structs::ELF_Rel.new(endian: @endian, offset: from)
-        rel.elf_class = @elf_class
-        rel.r_offset = address
-        relocation = Relocation.new(rel, @stream, machine: @machine)
+        fields = Structs::Fields.from(Structs::ELF_Rel, { r_offset: address, r_info: 0 },
+                                      elf_class: @elf_class, endian: @endian, offset: from)
+        relocation = Relocation.new(fields, @stream, machine: @machine)
         # Through the relocation, so that the type is laid out in +r_info+ the
         # way the machine lays it out.
         relocation.type = type if type

data/lib/elftools/relocation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'elftools/constants'
+require 'elftools/structs'
 require 'elftools/util'
 
 module ELFTools
@@ -8,22 +9,33 @@ module ELFTools
   #
   # 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 [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela, ELFTools::Structs::Fields] header
+    #   The relocation header, or what the file records in one.
+    #   {ELFTools::Structs::Fields} answers what the relocation records until
+    #   something asks for {#header} itself, which builds the structure then.
     # @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
+      @fields = header.is_a?(Structs::Fields) ? header : Structs::Fields.of(header)
       @stream = stream
       @machine = machine
     end
 
+    # The structure the file records this relocation in.
+    #
+    # One is built here for a relocation read without it, which is what
+    # assigning to a field of one needs and what {ELFTools::ELFFile#patches}
+    # reports the changes of.
+    # @return [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela] The structure.
+    def header
+      @fields.struct
+    end
+
     # Which symbol this relocation is against, as an index into the symbol
     # table.
     # @return [Integer] The symbol index.
@@ -44,7 +56,7 @@ module ELFTools
     # @example
     #   relocation.symbol_index = 3
     def symbol_index=(index)
-      header.r_info = info_of(Util.fits!(index, index_bits, 'Symbol index'), type)
+      @fields[:r_info] = info_of(Util.fits!(index, index_bits, 'Symbol index'), type)
     end
 
     # Sets what this relocation does.
@@ -53,7 +65,7 @@ module ELFTools
     # @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'))
+      @fields[:r_info] = info_of(symbol_index, Util.fits!(type, type_bits, 'Relocation type'))
     end
 
     # The name of {#type}.
@@ -83,8 +95,8 @@ module ELFTools
     # 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 = @fields[:r_info]
+      return (index << 32) | (info & 0xffff_ff00) | type if @fields.endian == :big
 
       (info & 0x00ff_ffff_0000_0000) | (type << 56) | index
     end
@@ -92,7 +104,7 @@ module ELFTools
     # How many bits record a symbol index.
     # @return [Integer] The number.
     def index_bits
-      mips64? ? 32 : (header.elf_class - mask_bit)
+      mips64? ? 32 : (@fields.elf_class - mask_bit)
     end
 
     # How many bits record a relocation type.
@@ -108,14 +120,15 @@ module ELFTools
     def sym_and_type
       return mips64_sym_and_type if mips64?
 
-      [header.r_info >> mask_bit, header.r_info & ((1 << mask_bit) - 1)]
+      info = @fields[:r_info]
+      [info >> mask_bit, 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
+      @machine == Constants::EM_MIPS && @fields.elf_class == 64
     end
 
     # Reads +r_info+ as the 64-bit MIPS ABI records it, i.e. a symbol index of
@@ -131,14 +144,14 @@ module ELFTools
     #   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 = @fields[:r_info]
+      return [info >> 32, info & 0xff] if @fields.endian == :big
 
       [info & 0xffff_ffff, info >> 56]
     end
 
     def mask_bit
-      header.elf_class == 32 ? 8 : 32
+      @fields.elf_class == 32 ? 8 : 32
     end
   end
 end

data/lib/elftools/sections/relocation_section.rb

@@ -78,12 +78,23 @@ module ELFTools
       private
 
       def create_relocation(n)
-        stream.pos = header.sh_offset + n * header.sh_entsize
         klass = rela? ? Structs::ELF_Rela : Structs::ELF_Rel
-        rel = klass.new(endian: header.class.self_endian, offset: stream.pos)
-        rel.elf_class = header.elf_class
-        rel.read(stream)
-        Relocation.new(rel, stream, machine: @machine)
+        fields = Structs::Fields.new(klass, stream, table_offset + (n * entsize),
+                                     elf_class: header.elf_class, endian: header.class.self_endian)
+        Relocation.new(fields, stream, machine: @machine)
+      end
+
+      # Where this table starts in the file, asked of the header once rather
+      # than once for every relocation read.
+      # @return [Integer] The file offset.
+      def table_offset
+        @table_offset ||= header.sh_offset.to_i
+      end
+
+      # How many bytes this table spaces its entries by.
+      # @return [Integer] The number.
+      def entsize
+        @entsize ||= header.sh_entsize.to_i
       end
     end
   end

data/lib/elftools/sections/sym_tab_section.rb

@@ -2,6 +2,7 @@
 
 require 'elftools/sections/section'
 require 'elftools/sections/symbol'
+require 'elftools/structs'
 require 'elftools/version_tables'
 
 module ELFTools
@@ -99,10 +100,31 @@ module ELFTools
       private
 
       def create_symbol(n)
-        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), machine: @machine, version: -> { version_at(n) })
+        Symbol.new(
+          Structs::Fields.new(Structs::ELF_sym[header.elf_class], stream, table_offset + (n * entsize),
+                              elf_class: header.elf_class, endian: header.class.self_endian),
+          stream, symstr: symstr_reader, machine: @machine, version: -> { version_at(n) }
+        )
+      end
+
+      # Where this table starts in the file, asked of the header once rather
+      # than once for every symbol read.
+      # @return [Integer] The file offset.
+      def table_offset
+        @table_offset ||= header.sh_offset.to_i
+      end
+
+      # How many bytes this table spaces its entries by.
+      # @return [Integer] The number.
+      def entsize
+        @entsize ||= header.sh_entsize.to_i
+      end
+
+      # What reads the section these symbols are named in, kept so that
+      # reading the table does not make one for every symbol.
+      # @return [Method] The method.
+      def symstr_reader
+        @symstr_reader ||= method(:symstr)
       end
 
       # The version the +n+-th symbol binds to.

data/lib/elftools/sections/symbol.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
 require 'elftools/constants'
+require 'elftools/structs'
 require 'elftools/util'
 
 module ELFTools
   module Sections
     # Class of symbol.
     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 [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym, ELFTools::Structs::Fields] header
+      #   The symbol header, or what the file records in one. {ELFTools::Structs::Fields}
+      #   answers what the symbol records until something asks for {#header}
+      #   itself, which builds the structure then.
       # @param [#pos=, #read] stream The streaming object.
       # @param [ELFTools::Sections::StrTabSection, Proc] symstr
       #   The symbol string section.
@@ -24,17 +26,27 @@ module ELFTools
       #   Call this to get the version this symbol binds to, which only the
       #   symbols a file is loaded by have.
       def initialize(header, stream, symstr: nil, machine: nil, version: nil)
-        @header = header
+        @fields = header.is_a?(Structs::Fields) ? header : Structs::Fields.of(header)
         @stream = stream
         @symstr = symstr
         @machine = machine
         @version = version
       end
 
+      # The structure the file records this symbol in.
+      #
+      # One is built here for a symbol read without it, which is what assigning
+      # to a field of a symbol needs and what {ELFTools::ELFFile#patches}
+      # reports the changes of.
+      # @return [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym] The structure.
+      def header
+        @fields.struct
+      end
+
       # Return the symbol name.
       # @return [String] The name.
       def name
-        @name ||= @symstr.call.name_at(header.st_name)
+        @name ||= @symstr.call.name_at(@fields[:st_name])
       end
 
       # The version this symbol binds to.
@@ -70,7 +82,7 @@ module ELFTools
       #   elf.section_by_name('.symtab').symbol_by_name('main').value
       #   #=> 4196061 # 0x4006dd
       def value
-        header.st_value.to_i
+        @fields[:st_value]
       end
 
       # How many bytes what this symbol names takes.
@@ -79,7 +91,7 @@ module ELFTools
       #   elf.section_by_name('.symtab').symbol_by_name('main').size
       #   #=> 142
       def size
-        header.st_size.to_i
+        @fields[:st_size]
       end
 
       # What kind of entity this symbol refers to.
@@ -90,7 +102,7 @@ module ELFTools
       #   symbol.type == ELFTools::Constants::STT_FUNC
       #   #=> true
       def type
-        header.st_info & 0xf
+        @fields[:st_info] & 0xf
       end
 
       # Sets what kind of entity this symbol refers to.
@@ -122,7 +134,7 @@ module ELFTools
       #   symbol.bind == ELFTools::Constants::STB_GLOBAL
       #   #=> true
       def bind
-        header.st_info >> 4
+        @fields[:st_info] >> 4
       end
 
       # Sets how this symbol is linked against others with the same name.
@@ -152,7 +164,7 @@ module ELFTools
       #   symbol.visibility == ELFTools::Constants::STV_HIDDEN
       #   #=> true
       def visibility
-        header.st_other & 0x3
+        @fields[:st_other] & 0x3
       end
 
       # Sets how this symbol is accessed once it becomes part of an executable
@@ -195,7 +207,7 @@ module ELFTools
       #   symbol.section_index == ELFTools::Constants::SHN_UNDEF
       #   #=> true # the symbol is undefined and to be resolved at runtime
       def section_index
-        header.st_shndx.to_i
+        @fields[:st_shndx]
       end
     end
   end

data/lib/elftools/structs.rb

@@ -2,6 +2,8 @@
 
 require 'bindata'
 
+require 'elftools/exceptions'
+
 module ELFTools
   # Define ELF related structures in this module.
   #
@@ -15,6 +17,23 @@ module ELFTools
         { selection: :elf_class, choices: { 32 => :"#{t}32", 64 => :"#{t}64" }, copy_on_change: true }
       end
 
+      # How an integer of each width is packed, for +String#unpack+, whether it
+      # records a sign or not.
+      UNPACK_TEMPLATES = {
+        little: {
+          false => { 1 => 'C', 2 => 'v', 4 => 'V', 8 => 'Q<' },
+          true => { 1 => 'c', 2 => 's<', 4 => 'l<', 8 => 'q<' }
+        },
+        big: {
+          false => { 1 => 'C', 2 => 'n', 4 => 'N', 8 => 'Q>' },
+          true => { 1 => 'c', 2 => 's>', 4 => 'l>', 8 => 'q>' }
+        }
+      }.freeze
+
+      # Bytes of set bits to read a prototype from, longer than any structure
+      # here, so that reading one never runs short of them.
+      SET_BITS = ("\xff" * 256).b.freeze
+
       attr_accessor :elf_class # @return [Integer] 32 or 64.
       attr_accessor :offset # @return [Integer] The file offset of this header.
 
@@ -103,9 +122,49 @@ module ELFTools
         end
 
         # Gets the endianness of current class.
+        #
+        # A class is of one endianness for as long as it exists, and asking
+        # bindata what it is named costs more than remembering the answer.
         # @return [:little, :big] The endianness.
         def self_endian
-          bindata_name[-2..] == 'be' ? :big : :little
+          @self_endian ||= bindata_name[-2..] == 'be' ? :big : :little
+        end
+
+        # What the fields of a structure record, read straight from its bytes.
+        #
+        # Reading a table of structures costs a structure for every entry of
+        # it otherwise, which is most of what reading the table costs. Nothing
+        # is remembered of the bytes, so a caller that means to assign to a
+        # field wants a structure instead.
+        # @param [String] bytes The bytes a structure is recorded in.
+        # @param [Integer] elf_class 32 or 64, which decides how wide the fields recording an address are.
+        # @param [:little, :big] endian The endianness the file records it in.
+        # @return [Hash{Symbol => Integer}] Each field, and what it records.
+        # @raise [ELFTools::ELFError] If this is not a structure of integers.
+        # @example
+        #   ELF64_sym.unpack_fields(bytes, elf_class: 64, endian: :little)
+        #   #=> { st_name: 1, st_info: 18, st_other: 0, st_shndx: 15, st_value: 4198864, st_size: 101 }
+        def unpack_fields(bytes, elf_class:, endian:)
+          values = bytes.unpack(unpack_template(elf_class, endian))
+          fields = {}
+          # Paired by hand rather than zipped, which would make an array for
+          # every field of every structure read.
+          field_names(elf_class, endian).each_with_index { |name, i| fields[name] = values[i] }
+          fields
+        end
+
+        # How many bytes a structure of this kind takes.
+        # @param [Integer] elf_class 32 or 64, which decides how wide the fields recording an address are.
+        # @param [:little, :big] endian The endianness the file records it in.
+        # @return [Integer] The number.
+        # @example
+        #   ELF64_sym.num_bytes(elf_class: 64, endian: :little)
+        #   #=> 24
+        def num_bytes(elf_class:, endian:)
+          @num_bytes ||= {}
+          # Nested rather than keyed by the pair, which would make an array of
+          # it for every structure read.
+          (@num_bytes[elf_class] ||= {})[endian] ||= prototype(elf_class, endian).num_bytes
         end
 
         # Packs an integer to string.
@@ -128,6 +187,210 @@ module ELFTools
           out = out.pack('C*')
           self_endian == :little ? out : out.reverse
         end
+
+        private
+
+        # A structure of this kind with every bit of it set, which the layout is
+        # read off: how wide each field is, and whether it records a sign.
+        #
+        # Every structure of a kind and a class is laid out alike, so one is
+        # built for the kind rather than for each question asked about it.
+        # @param [Integer] elf_class 32 or 64, which decides how wide the fields recording an address are.
+        # @param [:little, :big] endian The endianness the file records it in.
+        # @return [ELFTools::Structs::ELFStruct] The structure.
+        def prototype(elf_class, endian)
+          @prototypes ||= {}
+          (@prototypes[elf_class] ||= {})[endian] ||= begin
+            struct = new(endian: endian)
+            struct.elf_class = elf_class
+            struct.read(SET_BITS)
+          end
+        end
+
+        # What the fields of this structure are named, in the order they are
+        # recorded.
+        # @param [Integer] elf_class 32 or 64, which decides how wide the fields recording an address are.
+        # @param [:little, :big] endian The endianness the file records it in.
+        # @return [Array<Symbol>] The names.
+        def field_names(elf_class, endian)
+          @field_names ||= {}
+          (@field_names[elf_class] ||= {})[endian] ||= prototype(elf_class, endian).field_names
+        end
+
+        # How the fields of this structure are packed, as a template for
+        # +String#unpack+.
+        # @param [Integer] elf_class 32 or 64, which decides how wide the fields recording an address are.
+        # @param [:little, :big] endian The endianness the file records it in.
+        # @return [String] The template.
+        def unpack_template(elf_class, endian)
+          @unpack_templates ||= {}
+          (@unpack_templates[elf_class] ||= {})[endian] ||=
+            prototype(elf_class, endian).each_pair.map { |_, field| field_template(field, endian) }.join
+        end
+
+        # How one field is packed, which is its width and whether what it read
+        # from a field of set bits came back negative.
+        # @param [BinData::Base] field The field, read from bits that are all set.
+        # @param [:little, :big] endian The endianness the file records it in.
+        # @return [String] The template.
+        # @raise [ELFTools::ELFError] If the field is not an integer of 1, 2, 4, or 8 bytes.
+        def field_template(field, endian)
+          width = field.num_bytes
+          template = UNPACK_TEMPLATES.fetch(endian)
+          raise ELFError, format('%s is not a structure of integers', name) unless template[false].key?(width)
+
+          template.fetch(field.to_i.negative?)[width]
+        end
+      end
+    end
+
+    # What a structure the file records at an offset holds, read without
+    # building the structure.
+    #
+    # Reading a table of structures costs a structure for every entry of it
+    # otherwise, and setting up the fields of one is most of what it costs.
+    # {#struct} builds one for whatever wants the structure itself, which
+    # is what assigning to a field takes, and what is assigned is answered
+    # with from then on.
+    class Fields
+      attr_reader :elf_class # @return [Integer] 32 or 64.
+      attr_reader :endian # @return [:little, :big] The endianness the file records it in.
+
+      # What a structure already built holds, for a caller that has one.
+      # @param [ELFTools::Structs::ELFStruct] struct The structure.
+      # @return [ELFTools::Structs::Fields] The fields.
+      def self.of(struct)
+        allocate.tap { |fields| fields.send(:built_from, struct) }
+      end
+
+      # Fields nothing in the file records, for what a file states some other
+      # way than by recording a structure of it.
+      #
+      # There is nothing to read and nothing to patch, so a structure is only
+      # built if something asks for one, and is built from these.
+      # @param [Class] klass The structure class.
+      # @param [Hash{Symbol => Integer}] fields What each field is to record.
+      # @param [Integer] elf_class 32 or 64.
+      # @param [:little, :big] endian The endianness the file records it in.
+      # @param [Integer] offset Where in the file this came from.
+      # @return [ELFTools::Structs::Fields] The fields.
+      # @example
+      #   Fields.from(ELF_Rel, { r_offset: 0x1000 }, elf_class: 64, endian: :little, offset: 0x40)
+      def self.from(klass, fields, elf_class:, endian:, offset:)
+        allocate.tap { |made| made.send(:made_of, klass, fields, elf_class, endian, offset) }
+      end
+
+      # @param [Class] klass The structure class.
+      # @param [#pos=, #read] stream The streaming object.
+      # @param [Integer] offset The file offset the structure is recorded at.
+      # @param [Integer] elf_class 32 or 64.
+      # @param [:little, :big] endian The endianness the file records it in.
+      # @raise [EOFError] If the file does not reach that far.
+      def initialize(klass, stream, offset, elf_class:, endian:)
+        @klass = klass
+        @stream = stream
+        @offset = offset
+        @elf_class = elf_class
+        @endian = endian
+        @fields = unpack
+      end
+
+      # What one field of the structure records.
+      #
+      # The structure answers once there is one, so that a field assigned to
+      # reads back as it was assigned.
+      # @param [Symbol] name The name of the field.
+      # @return [Integer] The value.
+      # @example
+      #   fields[:st_value]
+      #   #=> 4198864
+      def [](name)
+        return @struct[name].to_i if @struct
+
+        @fields[name]
+      end
+
+      # Assigns to one field.
+      #
+      # The structure takes the assignment wherever the file records one, so
+      # that {ELFTools::ELFFile#patches} reports it. Fields the file records
+      # no structure of take it themselves, there being nothing to patch.
+      # @param [Symbol] name The name of the field.
+      # @param [Integer] value What it is to record.
+      # @return [void]
+      def []=(name, value)
+        if @struct.nil? && @stream.nil?
+          @fields[name] = value
+        else
+          struct[name] = value
+        end
+      end
+
+      # The structure itself, read from where the file records it, or built
+      # from these fields where it records none.
+      #
+      # The same one however often it is asked for, so that assigning to a
+      # field of it is not forgotten.
+      # @return [ELFTools::Structs::ELFStruct] The structure.
+      def struct
+        @struct ||= @stream.nil? ? build : read
+      end
+
+      private
+
+      # Takes a structure that is already built as what these fields hold.
+      # @param [ELFTools::Structs::ELFStruct] struct The structure.
+      # @return [void]
+      def built_from(struct)
+        @struct = struct
+        @elf_class = struct.elf_class
+        @endian = struct.class.self_endian
+      end
+
+      # Takes fields nothing in the file records a structure of.
+      # @return [void]
+      def made_of(klass, fields, elf_class, endian, offset)
+        @klass = klass
+        @fields = fields
+        @elf_class = elf_class
+        @endian = endian
+        @offset = offset
+      end
+
+      # The structure the file records, read from where it records it.
+      # @return [ELFTools::Structs::ELFStruct] The structure.
+      def read
+        struct = new_struct
+        @stream.pos = @offset
+        struct.read(@stream)
+      end
+
+      # A structure holding what these fields hold, for fields the file
+      # records no structure of.
+      # @return [ELFTools::Structs::ELFStruct] The structure.
+      def build
+        new_struct.tap { |struct| @fields.each { |name, value| struct[name] = value } }
+      end
+
+      # A structure of this kind, of the class and the order of the file, and
+      # of where in it this came from.
+      # @return [ELFTools::Structs::ELFStruct] The structure.
+      def new_struct
+        struct = @klass.new(endian: @endian, offset: @offset)
+        struct.elf_class = @elf_class
+        struct
+      end
+
+      # What the fields record, read from the bytes recording them.
+      # @return [Hash{Symbol => Integer}] Each field, and what it records.
+      # @raise [EOFError] If the file does not reach that far, as reading the structure itself does.
+      def unpack
+        num_bytes = @klass.num_bytes(elf_class: @elf_class, endian: @endian)
+        @stream.pos = @offset
+        bytes = @stream.read(num_bytes)
+        raise EOFError, 'End of file reached' if bytes.nil? || bytes.bytesize < num_bytes
+
+        @klass.unpack_fields(bytes, elf_class: @elf_class, endian: @endian)
       end
     end
 

data/lib/elftools/version.rb

@@ -2,5 +2,5 @@
 
 module ELFTools
   # Current gem version
-  VERSION = '2.1.0'
+  VERSION = '2.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elftools
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - david942j
@@ -259,7 +259,7 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-  changelog_uri: https://github.com/david942j/rbelftools/blob/v2.1.0/CHANGELOG.md
+  changelog_uri: https://github.com/david942j/rbelftools/blob/v2.2.0/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib