elftools 1.3.0 → 2.0.0

data/lib/elftools/dynamic/hash_table.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'elftools/structs'
+
+module ELFTools
+  module Dynamic
+    # A table of names the loader looks a symbol up in, instead of searching
+    # the symbol table for it.
+    #
+    # A file records one of two kinds, or both of them. Both answer the same
+    # two questions, how far the symbol table they index reaches and which
+    # index a name sits at, and differ in how they are laid out, in how they
+    # hash a name, and in which symbols they index at all.
+    class HashTable
+      # Instantiate a {ELFTools::Dynamic::HashTable} object.
+      # @param [#pos=, #read] stream Streaming object.
+      # @param [Integer] offset The file offset the table starts at.
+      # @param [Integer] elf_class 32 or 64, the width of a mask of the table.
+      # @param [Symbol] endian +:little+ or +:big+.
+      def initialize(stream, offset, elf_class:, endian:)
+        @stream = stream
+        @offset = offset
+        @elf_class = elf_class
+        @endian = endian
+      end
+
+      private
+
+      # The header the table starts with.
+      # @return [ELFTools::Structs::ELFStruct] The header.
+      def header
+        @header ||= begin
+          @stream.pos = @offset
+          self.class::HEADER.new(endian: @endian).read(@stream)
+        end
+      end
+
+      # Reads the four-byte word at an offset into the table, the unit buckets
+      # and chains are laid out in.
+      # @param [Integer] offset The offset into the table.
+      # @return [Integer] The word.
+      def word_at(offset)
+        read_at(offset, 4)
+      end
+
+      # Reads an unsigned integer at an offset into the table.
+      # @param [Integer] offset The offset into the table.
+      # @param [Integer] bytes How many bytes it takes, 4 or 8.
+      # @return [Integer] The integer.
+      def read_at(offset, bytes)
+        @stream.pos = @offset + offset
+        @stream.read(bytes).unpack1("#{bytes == 4 ? 'L' : 'Q'}#{@endian == :big ? '>' : '<'}")
+      end
+
+      # The table +DT_HASH+ points at, which the System V ABI defines.
+      #
+      # A chain of it belongs to every symbol, so it is the one table that
+      # records how many there are.
+      class SysV < HashTable
+        # The header the table starts with.
+        HEADER = Structs::ELF_Hash
+
+        # How many symbols the table is built over, which it records outright.
+        # @return [Integer] The number.
+        def num_symbols
+          header.nchain.to_i
+        end
+
+        # The index a name sits at.
+        #
+        # A bucket leads to a chain of the indices whose names hash alike, so
+        # the block is what tells them apart.
+        # @param [String] name The name.
+        # @yieldparam [Integer] index An index whose name hashes like +name+.
+        # @yieldreturn [Boolean] Whether the symbol there is the one wanted.
+        # @return [Integer, nil]
+        #   The index, +nil+ if the table does not lead to the name.
+        def index_of(name)
+          return if header.nbucket.to_i.zero?
+
+          n = word_at(buckets + ((hash_of(name) % header.nbucket.to_i) * 4))
+          # Index zero is the undefined symbol, so it ends a chain instead of
+          # belonging to one.
+          while n.positive? && n < num_symbols
+            return n if yield(n)
+
+            n = word_at(chain + (n * 4))
+          end
+        end
+
+        private
+
+        # Where the buckets start, as an offset into the table.
+        # @return [Integer] The offset.
+        def buckets
+          header.num_bytes
+        end
+
+        # Where the chains start, as an offset into the table.
+        # @return [Integer] The offset.
+        def chain
+          buckets + (header.nbucket.to_i * 4)
+        end
+
+        # The hash the System V ABI defines, which keeps a name in 28 bits.
+        # @param [String] name The name.
+        # @return [Integer] The hash.
+        def hash_of(name)
+          name.each_byte.reduce(0) do |h, c|
+            h = (h << 4) + c
+            top = h & 0xf000_0000
+            (h ^ (top >> 24)) & ~top
+          end
+        end
+      end
+
+      # The table +DT_GNU_HASH+ points at.
+      #
+      # It only indexes the defined symbols a file exports under a name, and
+      # the symbols before {#symndx} are by construction not among them, so a
+      # name it does not lead to may still be in the symbol table.
+      class Gnu < HashTable
+        # The header the table starts with.
+        HEADER = Structs::ELF_GnuHash
+
+        # How far the table reaches, i.e. the highest index it indexes plus one.
+        # @return [Integer] The number.
+        def num_symbols
+          last = Array.new(header.nbuckets.to_i) { |i| word_at(buckets + (i * 4)) }.max || 0
+          return symndx if last < symndx
+
+          n = last - symndx
+          n += 1 while word_at(chain + (n * 4)).even?
+          symndx + n + 1
+        end
+
+        # The index a name sits at.
+        #
+        # A bucket leads to a chain of the indices whose names hash alike, so
+        # the block is what tells them apart.
+        # @param [String] name The name.
+        # @yieldparam [Integer] index An index whose name hashes like +name+.
+        # @yieldreturn [Boolean] Whether the symbol there is the one wanted.
+        # @return [Integer, nil]
+        #   The index, +nil+ if the table does not lead to the name.
+        def index_of(name, &block)
+          return if header.nbuckets.to_i.zero? || header.maskwords.to_i.zero?
+
+          h = hash_of(name)
+          return unless may_index?(h)
+
+          n = word_at(buckets + ((h % header.nbuckets.to_i) * 4))
+          return if n.zero? || n < symndx
+
+          walk(n, h, &block)
+        end
+
+        private
+
+        # The first symbol index the table indexes.
+        # @return [Integer] The index.
+        def symndx
+          header.symndx.to_i
+        end
+
+        # Where the buckets start, as an offset into the table.
+        # @return [Integer] The offset.
+        def buckets
+          header.num_bytes + (header.maskwords.to_i * @elf_class / 8)
+        end
+
+        # Where the chains start, as an offset into the table.
+        # @return [Integer] The offset.
+        def chain
+          buckets + (header.nbuckets.to_i * 4)
+        end
+
+        # Walks the chain a bucket leads to, whose entries are the hashes of
+        # the names it holds, with the lowest bit marking the last of them.
+        # @param [Integer] index The index the bucket leads to.
+        # @param [Integer] hash The hash of the name wanted.
+        # @return [Integer, nil] The index, +nil+ if the chain ends without it.
+        def walk(index, hash)
+          loop do
+            # The lowest bit belongs to the chain rather than to the hash.
+            value = word_at(chain + ((index - symndx) * 4))
+            return index if (value | 1) == (hash | 1) && yield(index)
+            break if value.odd?
+
+            index += 1
+          end
+        end
+
+        # Whether the filter in front of the table rules a hash out, which it
+        # answers for a name the file does not export without the table being
+        # read at all. Looking a name up across a chain of files is what it is
+        # there for.
+        # @param [Integer] hash The hash.
+        # @return [Boolean] Whether the name may be indexed.
+        def may_index?(hash)
+          width = @elf_class / 8
+          word = read_at(header.num_bytes + (((hash / @elf_class) % header.maskwords.to_i) * width), width)
+          mask = (1 << (hash % @elf_class)) | (1 << ((hash >> header.shift2.to_i) % @elf_class))
+          word & mask == mask
+        end
+
+        # The hash GNU defines, which is djb2.
+        # @param [String] name The name.
+        # @return [Integer] The hash.
+        def hash_of(name)
+          name.each_byte.reduce(5381) { |h, c| ((h * 33) + c) & 0xffff_ffff }
+        end
+      end
+    end
+  end
+end

data/lib/elftools/dynamic/string_table.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'elftools/util'
+
+module ELFTools
+  module Dynamic
+    # The names a file records, which the tags point at rather than a section.
+    #
+    # Answers what {ELFTools::Sections::StrTabSection} answers, so that what is
+    # read from the tags names itself the way what is read from the sections
+    # does.
+    class StringTable
+      # Instantiate a {ELFTools::Dynamic::StringTable} object.
+      # @param [#pos=, #read] stream Streaming object.
+      # @param [Method] offset
+      #   Call this method to get the file offset the table starts at.
+      def initialize(stream, offset)
+        @stream = stream
+        @offset = offset
+      end
+
+      # Return the name recorded at an offset into the table.
+      # @param [Integer] offset Usually from +tag.d_val+ or +sym.st_name+.
+      # @return [String] The name without null bytes.
+      def name_at(offset)
+        Util.cstring(@stream, @offset.call + offset)
+      end
+    end
+  end
+end

data/lib/elftools/dynamic/symbols.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'elftools/dynamic/hash_table'
+require 'elftools/exceptions'
+require 'elftools/sections/symbol'
+require 'elftools/structs'
+
+module ELFTools
+  module Dynamic
+    # The symbols a file is loaded by, which the tags point at.
+    #
+    # @note
+    #   This module is included by {ELFTools::Dynamic} and reads through the
+    #   methods there, so it cannot be included on its own.
+    module Symbols
+      # Get the +n+-th symbol.
+      #
+      # Symbols are lazy loaded.
+      # @note
+      #   We cannot do bound checking of +n+ here, because nothing records how
+      #   many symbols there are. {#num_symbols} is a lower bound rather than a
+      #   bound, so checking against it would hide symbols this method reads
+      #   correctly.
+      # @param [Integer] n The index.
+      # @return [ELFTools::Sections::Symbol] The desired symbol.
+      # @raise [ELFTools::ELFError]
+      #   If +DT_SYMTAB+ is absent, or its address is not in any loadable segment.
+      def symbol_at(n)
+        return if n.negative?
+
+        @symbol_at_map ||= {}
+        @symbol_at_map[n] ||= begin
+          klass = Structs::ELF_sym[header.elf_class]
+          # An entry takes what its structure takes, which is also what
+          # DT_SYMENT records and what a file has no way of disagreeing with.
+          sym = read_struct(klass, sym_offset + (n * struct(klass).num_bytes))
+          Sections::Symbol.new(sym, stream, symstr: method(:string_table), machine: @machine)
+        end
+      end
+
+      # How many symbols the tags reach.
+      #
+      # Nothing a file is loaded by records how large its symbol table is. The
+      # loader never enumerates it: it looks a name up through a hash table and
+      # jumps straight to an index, so where the table ends is none of its
+      # business. Two things bound it instead, the hash table that indexes the
+      # names a file exports and the relocations that name a symbol by index,
+      # and the answer is how far the further of the two reaches. Only +DT_HASH+
+      # records the number outright.
+      #
+      # This is therefore a lower bound. A symbol that is neither indexed by the
+      # hash table nor named by a relocation is invisible to both, and is
+      # missing from the count. {#symbol_at} is exact for any index.
+      # @return [Integer] The number.
+      # @example
+      #   elf.dynamic.num_symbols
+      #   #=> 9
+      def num_symbols
+        @num_symbols ||= (hash_tables.map(&:num_symbols) + [count_from_relocations]).compact.max || 0
+      end
+
+      # Iterate all symbols.
+      #
+      # Symbols are lazy loaded, so {#symbol_by_name} only creates the symbols
+      # it has to look at.
+      # @yieldparam [ELFTools::Sections::Symbol] symbol A symbol object.
+      # @yieldreturn [void]
+      # @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_symbol(&block)
+        return enum_for(:each_symbol) unless block_given?
+
+        Array.new(num_symbols) { |i| symbol_at(i).tap(&block) }
+      end
+
+      # The name this used to go by, kept so that it keeps working.
+      alias each_symbols each_symbol
+
+      # The symbols the tags point at, which is where a file that has been
+      # stripped of its sections still records them.
+      #
+      # As many of them as {#num_symbols} reaches.
+      # @return [Array<ELFTools::Sections::Symbol>] The symbols.
+      # @example
+      #   elf.dynamic.symbols.map(&:name)
+      #   #=> ['', 'puts', '__stack_chk_fail', 'printf', '__libc_start_main']
+      def symbols
+        each_symbol.to_a
+      end
+
+      # Get symbol by its name.
+      #
+      # The hash tables answer first, which is the lookup the loader itself
+      # performs and takes no scanning. They do not index every symbol, and a
+      # file need not record one at all, so a name they do not lead to is
+      # searched for among the symbols {#symbols} reaches.
+      # @param [String] name The name of symbol.
+      # @return [ELFTools::Sections::Symbol, nil] The desired symbol.
+      # @example
+      #   elf.dynamic.symbol_by_name('__libc_start_main').type_name
+      #   #=> 'STT_FUNC'
+      def symbol_by_name(name)
+        # Lazily, so that a table is only read when the ones before it have
+        # not led anywhere.
+        index = hash_tables.lazy.filter_map { |table| table.index_of(name) { |i| symbol_at(i).name == name } }.first
+        return symbol_at(index) if index
+
+        each_symbol.find { |symbol| symbol.name == name }
+      end
+
+      private
+
+      # The tables the file records the names it exports in, of whichever kinds
+      # it records.
+      # @return [Array<ELFTools::Dynamic::HashTable>] The tables.
+      def hash_tables
+        @hash_tables ||= { hash: HashTable::SysV, gnu_hash: HashTable::Gnu }.filter_map do |type, klass|
+          tag = tag_by_type(type)
+          klass.new(stream, offset_of(tag), elf_class: header.elf_class, endian:) if tag
+        end
+      end
+
+      # How far the relocations reach, i.e. the highest index they name plus one.
+      # They only ever name the symbols something in the file refers to.
+      # @return [Integer, nil] The number, +nil+ if none names a symbol.
+      def count_from_relocations
+        highest = relocations.map(&:symbol_index).max
+        highest && highest + 1
+      end
+
+      # Get the +DT_SYMTAB+'s +d_val+ offset related to file.
+      # @return [Integer] The file offset.
+      # @raise [ELFTools::ELFError]
+      #   If +DT_SYMTAB+ is absent, or its address is not in any loadable segment.
+      def sym_offset
+        @sym_offset ||= begin
+          symtab = tag_by_type(:symtab)
+          raise ELFError, 'DT_SYMTAB not found' if symtab.nil?
+
+          offset_of(symtab)
+        end
+      end
+    end
+  end
+end

data/lib/elftools/dynamic/tag.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'elftools/constants'
+
+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 [#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
+        @stream = stream
+        @strtab = strtab
+      end
+
+      # Some dynamic have name.
+      TYPE_WITH_NAME = [Constants::DT_NEEDED,
+                        Constants::DT_SONAME,
+                        Constants::DT_RPATH,
+                        Constants::DT_RUNPATH].freeze
+      # Return the content of this tag records.
+      #
+      # For normal tags, this method just return
+      # +header.d_val+. For tags with +header.d_val+
+      # in meaning of string offset (e.g. DT_NEEDED), this method would
+      # return the string it specified.
+      # Tags with type in {TYPE_WITH_NAME} are those tags with name.
+      # @return [Integer, String] The content this tag records.
+      # @example
+      #   dynamic = elf.segment_by_type(:dynamic)
+      #   dynamic.tag_by_type(:init).value
+      #   #=> 4195600 # 0x400510
+      #   dynamic.tag_by_type(:needed).value
+      #   #=> 'libc.so.6'
+      def value
+        name || header.d_val.to_i
+      end
+
+      # Is this tag has a name?
+      #
+      # 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)
+      end
+
+      # Return the name of this tag.
+      #
+      # Only tags with name would return a name.
+      # Others would return +nil+.
+      # @return [String, nil] The name.
+      def name
+        return nil unless name?
+
+        @strtab.name_at(header.d_val.to_i)
+      end
+    end
+  end
+end

data/lib/elftools/dynamic.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
+require 'elftools/constants'
+require 'elftools/dynamic/string_table'
+require 'elftools/dynamic/symbols'
+require 'elftools/dynamic/tag'
+require 'elftools/exceptions'
+require 'elftools/relocation'
+require 'elftools/structs'
+
 module ELFTools
   # Define common methods for dynamic sections and dynamic segments.
   #
@@ -8,6 +16,8 @@ module ELFTools
   #   and {ELFTools::Segments::DynamicSegment} because methods here assume some
   #   attributes exist.
   module Dynamic
+    include Symbols
+
     # Iterate all tags.
     #
     # @note
@@ -18,8 +28,8 @@ module ELFTools
     # @return [Enumerator<ELFTools::Dynamic::Tag>, Array<ELFTools::Dynamic::Tag>]
     #   If block is not given, an enumerator will be returned.
     #   Otherwise, return array of tags.
-    def each_tags(&block)
-      return enum_for(:each_tags) unless block_given?
+    def each_tag(&block)
+      return enum_for(:each_tag) unless block_given?
 
       arr = []
       0.step do |i|
@@ -30,11 +40,14 @@ module ELFTools
       arr
     end
 
+    # The name this used to go by, kept so that it keeps working.
+    alias each_tags each_tag
+
     # Use {#tags} to get all tags.
     # @return [Array<ELFTools::Dynamic::Tag>]
     #   Array of tags.
     def tags
-      @tags ||= each_tags.to_a
+      @tags ||= each_tag.to_a
     end
 
     # Get a tag of specific type.
@@ -63,7 +76,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_tags.find { |tag| tag.header.d_tag == type }
+      each_tag.find { |tag| tag.header.d_tag == type }
     end
 
     # Get tags of specific type.
@@ -75,7 +88,7 @@ module ELFTools
     # @see #tag_by_type
     def tags_by_type(type)
       type = Util.to_constant(Constants::DT, type)
-      each_tags.select { |tag| tag.header.d_tag == type }
+      each_tag.select { |tag| tag.header.d_tag == type }
     end
 
     # Get the +n+-th tag.
@@ -100,7 +113,22 @@ module ELFTools
       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, method(:str_offset))
+      @tag_at_map[n] = Tag.new(dyn.read(stream), stream, string_table)
+    end
+
+    # The relocations the tags point at.
+    #
+    # Two tables record them: the one +DT_REL+ or +DT_RELA+ names, and the one
+    # +DT_JMPREL+ names, whose entries are of the kind +DT_PLTREL+ names.
+    # @return [Array<ELFTools::Relocation>] The relocations, in the order the
+    #   tags record them.
+    # @raise [ELFTools::ELFError]
+    #   If a table is not in any loadable segment.
+    # @example
+    #   elf.dynamic.relocations.map(&:type_name).uniq
+    #   #=> ['R_X86_64_GLOB_DAT', 'R_X86_64_JUMP_SLOT']
+    def relocations
+      @relocations ||= relocation_tables.flat_map { |start, size, rela| read_relocations(start, size, rela) }
     end
 
     private
@@ -109,69 +137,81 @@ module ELFTools
       header.class.self_endian
     end
 
-    # Get the DT_STRTAB's +d_val+ offset related to file.
-    def str_offset
-      # TODO: handle DT_STRTAB not exitsts.
-      @str_offset ||= @offset_from_vma.call(tag_by_type(:strtab).header.d_val.to_i)
+    # Where each table of relocations starts, the tag recording how many bytes
+    # it takes, and whether its entries record an addend.
+    # @return [Array<Array(ELFTools::Dynamic::Tag, ELFTools::Dynamic::Tag, Boolean)>] The tables.
+    def relocation_tables
+      tables = %i[rel rela].filter_map do |type|
+        tag = tag_by_type(type)
+        [tag, tag_by_type(:"#{type}sz"), type == :rela] if tag
+      end
+      jmprel = tag_by_type(:jmprel)
+      return tables if jmprel.nil?
+
+      tables << [jmprel, tag_by_type(:pltrelsz), tag_by_type(:pltrel).header.d_val.to_i == Constants::DT_RELA]
     end
 
-    # 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 [#pos=, #read] stream Streaming object.
-      # @param [Method] str_offset
-      #   Call this method to get the string offset related
-      #   to file.
-      def initialize(header, stream, str_offset)
-        @header = header
-        @stream = stream
-        @str_offset = str_offset
+    # Reads one table of relocations.
+    # @return [Array<ELFTools::Relocation>] The relocations.
+    def read_relocations(start, size, rela)
+      klass = rela ? Structs::ELF_Rela : Structs::ELF_Rel
+      offset = offset_of(start)
+      # 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
+      Array.new(size.header.d_val.to_i / entsize) do |i|
+        Relocation.new(read_struct(klass, offset + (i * entsize)), stream, machine: @machine)
       end
+    end
 
-      # Some dynamic have name.
-      TYPE_WITH_NAME = [Constants::DT_NEEDED,
-                        Constants::DT_SONAME,
-                        Constants::DT_RPATH,
-                        Constants::DT_RUNPATH].freeze
-      # Return the content of this tag records.
-      #
-      # For normal tags, this method just return
-      # +header.d_val+. For tags with +header.d_val+
-      # in meaning of string offset (e.g. DT_NEEDED), this method would
-      # return the string it specified.
-      # Tags with type in {TYPE_WITH_NAME} are those tags with name.
-      # @return [Integer, String] The content this tag records.
-      # @example
-      #   dynamic = elf.segment_by_type(:dynamic)
-      #   dynamic.tag_by_type(:init).value
-      #   #=> 4195600 # 0x400510
-      #   dynamic.tag_by_type(:needed).value
-      #   #=> 'libc.so.6'
-      def value
-        name || header.d_val.to_i
-      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
 
-      # Is this tag has a name?
-      #
-      # 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)
-      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
 
-      # Return the name of this tag.
-      #
-      # Only tags with name would return a name.
-      # Others would return +nil+.
-      # @return [String, nil] The name.
-      def name
-        return nil unless name?
+    # The file offset the address a tag records points at.
+    # @param [ELFTools::Dynamic::Tag] tag The tag.
+    # @return [Integer] The file offset.
+    # @raise [ELFTools::ELFError]
+    #   If the address is not in any loadable segment.
+    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))
+    end
+
+    # The names the tags and the symbols point at.
+    # @return [ELFTools::Dynamic::StringTable] The string table.
+    def string_table
+      @string_table ||= StringTable.new(stream, method(:str_offset))
+    end
+
+    # Get the DT_STRTAB's +d_val+ offset related to file.
+    # @return [Integer] The file offset.
+    # @raise [ELFTools::ELFError]
+    #   If DT_STRTAB is absent, or its address is not in any loadable segment.
+    def str_offset
+      @str_offset ||= begin
+        strtab = tag_by_type(:strtab)
+        raise ELFError, 'DT_STRTAB not found' if strtab.nil?
 
-        Util.cstring(stream, @str_offset.call + header.d_val.to_i)
+        offset_of(strtab)
       end
     end
   end