elf_utils 0.3.0

data/lib/elf_utils/section/debug_line/line_number_program/state_machine.rb

@@ -0,0 +1,206 @@
+class ElfUtils::Section::DebugLine
+  class LineNumberProgram::StateMachine
+    include CTypes::Helpers
+
+    StandardOpCodes = ElfUtils::Types::Dwarf::StandardOpCodes
+    ExtendedOpCodes = ElfUtils::Types::Dwarf::ExtendedOpCodes
+    ULEB128 = ElfUtils::Types::ULEB128
+    SLEB128 = ElfUtils::Types::SLEB128
+
+    StateRegisters = Struct.new("StateRegisters", :address, :op_index, :file,
+      :line, :column, :is_stmt, :basic_block, :end_sequence, :prologue_end,
+      :epilogue_begin, :isa, :discriminator, keyword_init: true) do
+        def initialize(args)
+          # save off values we need for `#advance`
+          @maximum_operations_per_instruction =
+            args.delete(:maximum_operations_per_instruction)
+          @minimum_instruction_length = args.delete(:minimum_instruction_length)
+
+          # add the hard-coded defaults
+          args.merge!(
+            address: 0,
+            op_index: 0,
+            file: 1,
+            line: 1,
+            column: 0,
+            basic_block: false,
+            end_sequence: false,
+            prologue_end: false,
+            epilogue_begin: false,
+            isa: 0,
+            discriminator: 0
+          )
+
+          # save off the initial values to support `#reset`
+          @initial_values = args
+          super
+        end
+
+        # advance `address` & `op_index` by the provided `operation_advance`
+        def advance(operation_advance)
+          self.address += @minimum_instruction_length *
+            ((op_index + operation_advance) /
+              @maximum_operations_per_instruction)
+          self.op_index = (op_index + operation_advance) %
+            @maximum_operations_per_instruction
+        end
+
+        # reset the registers to their initial values
+        def reset
+          @initial_values.each { |k, v| self[k] = v }
+        end
+
+        def flags
+          flags = []
+          %i[is_stmt basic_block end_sequence prologue_end epilogue_begin]
+            .each { |f| flags << f if send(f) }
+          flags
+        end
+
+        def to_s
+          "0x%016x %6d %6d %6d %3d %13d  %s" % [
+            address, line, column, file, isa, discriminator, flags.join(" ")
+          ]
+        end
+      end
+
+    def initialize(program)
+      @opcode_base = program.header.opcode_base
+      @standard_opcode_lengths = program.standard_opcode_lengths
+      @special_opcodes = build_special_opcode_table(program.header)
+      @addr_type = program.file.elf_type(:Addr)
+
+      # initial state
+      @initial_registers = StateRegisters.new(
+        minimum_instruction_length: program.header.minimum_instruction_length,
+        maximum_operations_per_instruction: (program.header.version >= 4) ?
+            program.header.maximum_operations_per_instruction : 1,
+        is_stmt: program.header.default_is_stmt == 1
+      ).freeze
+    end
+
+    def process(opcodes)
+      buf = opcodes
+      opcode_base = @opcode_base
+      matrix = []
+      registers = @initial_registers.dup
+
+      # TODO merge unpack & eval steps for extended & special opcodes
+      until buf.empty?
+        byte = uint8.unpack(buf)
+        if byte == 0
+          opcode, args, buf = unpack_extended_op(buf[1..])
+          eval_extended_opcode(matrix, registers, opcode, args)
+        elsif byte < opcode_base
+          buf = eval_standard_opcode(buf, matrix, registers)
+        else
+          opcode, buf = byte, buf[1..]
+          opcode = @special_opcodes[opcode]
+          eval_special_opcode(matrix, registers, opcode)
+        end
+      end
+
+      matrix
+    end
+
+    private
+
+    # construct a special opcode table to lookup the values for each special
+    # opcode
+    def build_special_opcode_table(program_header)
+      opcode_base = program_header.opcode_base
+
+      (opcode_base..255).each_with_object([]) do |opcode, o|
+        adjusted_opcode = opcode - opcode_base
+
+        o[opcode] = {
+          line_increment: program_header.line_base +
+            (adjusted_opcode % program_header.line_range),
+          operation_advance: adjusted_opcode / program_header.line_range
+        }
+        o
+      end
+    end
+
+    def unpack_extended_op(buf)
+      size, buf = ULEB128.unpack_one(buf)
+      opcode, buf = uint8.unpack_one(buf)
+      args, buf = if size > 1
+        string(size - 1, trim: false).unpack_one(buf)
+      else
+        ["", buf]
+      end
+      [ExtendedOpCodes[opcode] || opcode, args, buf]
+    end
+
+    def eval_special_opcode(matrix, reg, opcode)
+      reg.advance(opcode[:operation_advance])
+      reg.line += opcode[:line_increment]
+      matrix << reg.dup
+      reg.basic_block = false
+      reg.prologue_end = false
+      reg.epilogue_begin = false
+      reg.discriminator = 0
+    end
+
+    def eval_standard_opcode(buf, matrix, reg)
+      opcode, buf = uint8.unpack_one(buf)
+      case StandardOpCodes[opcode]
+      when :copy
+        matrix << reg.dup
+        reg.discriminator = 0
+        reg.basic_block = false
+        reg.prologue_end = false
+        reg.epilogue_begin = false
+      when :advance_pc
+        operation_advance, buf = ULEB128.unpack_one(buf)
+        reg.advance(operation_advance)
+      when :advance_line
+        lines, buf = SLEB128.unpack_one(buf)
+        reg.line += lines
+      when :set_file
+        reg.file, buf = ULEB128.unpack_one(buf)
+      when :set_column
+        reg.column, buf = ULEB128.unpack_one(buf)
+      when :negate_stmt
+        reg.is_stmt = !reg.is_stmt
+      when :set_basic_block
+        reg.basic_block = true
+      when :const_add_pc
+        reg.advance(@special_opcodes[255][:operation_advance])
+      when :fixed_advance_pc
+        offset, buf = uint16.unpack_one(buf)
+        reg.address += offset
+        reg.op_index = 0
+      when :set_prologue_end
+        reg.prologue_end = true
+      when :set_epilogue_begin
+        reg.epilogue_begin = true
+      when :set_isa
+        reg.isa, buf = ULEB128.unpack_one(buf)
+      else
+        # for unsupported opcodes, skip the arguments
+        _, buf = array(ULEB128, @standard_opcode_lengths[opcode])
+          .unpack_one(buf)
+      end
+
+      buf
+    end
+
+    def eval_extended_opcode(matrix, reg, opcode, args)
+      case opcode
+      when :end_sequence
+        reg.end_sequence = true
+        matrix << reg.dup
+        reg.reset
+      when :set_address
+        reg.address = @addr_type.unpack(args)
+        reg.op_index = 0
+      when :set_discriminator
+        reg.discriminator = ULEB128.unpack(args)
+      else
+        raise ElfUtils::Error, "unknown opcode: %p %p" % [opcode, args]
+      end
+    end
+  end
+end

data/lib/elf_utils/section/debug_line/line_number_program.rb

@@ -0,0 +1,134 @@
+class ElfUtils::Section::DebugLine
+  class LineNumberProgram
+    include CTypes::Helpers
+
+    def initialize(file:, offset:, header:, body:)
+      @file = file
+      @offset = offset
+      @header = header
+      @body = body
+    end
+    attr_reader :body, :file, :header
+
+    def addr_type
+      @header.addr_type
+    end
+
+    def standard_opcode_lengths
+      unpack_header_tail unless @standard_opcode_lengths
+      @standard_opcode_lengths
+    end
+
+    def directories
+      unpack_header_tail unless @directories
+      @directories
+    end
+
+    def file_names
+      unpack_header_tail unless @file_names
+      @file_names
+    end
+
+    def file_name(index)
+      file_name = file_names[index]
+      dir = directories[file_name[:directory_index]]
+      File.join(dir[:path], file_name[:path])
+    end
+
+    def address_table
+      @address_table ||= begin
+        state = StateMachine.new(self)
+        state.process(body).each_with_object({}) do |entry, o|
+          o[entry.address] = entry.freeze
+        end.freeze
+      end
+    end
+
+    def source_location(addr)
+      entry = address_table[addr] || return
+      {
+        file: file_name(entry.file),
+        line: entry.line,
+        column: entry.column
+      }
+    end
+
+    private
+
+    def unpack_header_tail
+      buf = header._rest
+      @standard_opcode_lengths, buf = array(uint8, header.opcode_base - 1)
+        .unpack_one(buf)
+      @standard_opcode_lengths.unshift(nil)
+
+      # unpack directory entries
+      if header.version < 5
+        @directories, buf = unpack_terminated_entries(buf,
+          Header::INCLUDE_DIRECTORIES_FORMAT)
+
+        # Prior to DWARF v5, the include directories were 1-indexed.  Insert a
+        # nil at index 0, shifting all the entires up one index.
+        @directories.unshift(nil)
+      else
+        format, count, buf = unpack_format_and_count(buf)
+        @directories, buf = unpack_count_entries(buf, format, count)
+      end
+
+      # unpack file_name entries
+      if header.version < 5
+        @file_names, = unpack_terminated_entries(buf, Header::FILE_NAMES_FORMAT)
+        @file_names.unshift(nil)
+      else
+        format, count, buf = unpack_format_and_count(buf)
+        @file_names, = unpack_count_entries(buf, format, count)
+      end
+    end
+
+    def unpack_format_and_count(buf)
+      format_count, buf = uint8.unpack_one(buf)
+      format, buf = array(Header::EntryFormat, format_count).unpack_one(buf)
+      count, buf = ElfUtils::Types::ULEB128.unpack_one(buf)
+      [format, count, buf]
+    end
+
+    def unpack_count_entries(buf, format, count)
+      entries = count.times.map do
+        entry, buf = unpack_entry(buf, format)
+        entry
+      end
+      [entries, buf]
+    end
+
+    def unpack_terminated_entries(buf, format)
+      entries = []
+      until buf[0] == "\0"
+        entry, buf = unpack_entry(buf, format)
+        entries << entry
+      end
+      [entries, buf[1..]]
+    end
+
+    def unpack_entry(buf, format)
+      entry = {}
+      format.each do |field|
+        case field.form
+        when :string
+          entry[field.type], buf = string.terminated.unpack_one(buf)
+        when :line_strp
+          offset, buf = addr_type.unpack_one(buf)
+          entry[field.type] = @file.section(".debug_line_str")[offset]
+        when :udata
+          entry[field.type], buf = ElfUtils::Types::ULEB128.unpack_one(buf)
+        when :data16
+          entry[field.type], buf = string(16, trim: false).unpack_one(buf)
+        else
+          raise ElfUtils::Error, "unsupported entry field form: %p" % [field]
+        end
+      end
+      [entry, buf]
+    end
+  end
+end
+
+require_relative "line_number_program/header"
+require_relative "line_number_program/state_machine"

data/lib/elf_utils/section/debug_line.rb

@@ -0,0 +1,35 @@
+module ElfUtils
+  class Section::DebugLine < Section::Base
+    def line_number_programs
+      out = []
+      buf = bytes
+      until buf.empty?
+        program, buf = unpack_line_number_program(buf)
+        out << program
+      end
+      out
+    end
+
+    def line_number_program(offset)
+      program, = unpack_line_number_program(bytes[offset..])
+      program
+    end
+
+    private
+
+    def unpack_line_number_program(buf)
+      header, rest = LineNumberProgram::Header
+        .with_endian(@file.endian)
+        .unpack_one(buf)
+      header.freeze
+      header_size = buf.size - rest.size
+      body_size = header.unit.unit_size - header_size
+      body = rest[0, body_size]
+      program = LineNumberProgram
+        .new(file: @file, offset:, header: header.inner, body:)
+      [program, buf[header.unit.unit_size..]]
+    end
+  end
+end
+
+require_relative "debug_line/line_number_program"

data/lib/elf_utils/section/debug_ranges.rb

@@ -0,0 +1,22 @@
+module ElfUtils
+  class Section::DebugRanges < Section::Base
+    include CTypes::Helpers
+
+    # get the range list at a given offset
+    def get(offset:, base:)
+      array(array(@file.addr_type, 2), terminator: [0, 0])
+        .unpack(bytes[offset..])
+        .map do |first, last|
+          if first == @file.addr_type.max
+            # TODO figure out how to generate a test file that makes use of
+            # DW_AT_ranges & has a base address range so we can add tests for
+            # this.
+            base = last
+            nil
+          else
+            (first + base)..(last + base - 1)
+          end
+        end.compact
+    end
+  end
+end

data/lib/elf_utils/section/debug_str_offsets.rb

@@ -0,0 +1,16 @@
+module ElfUtils
+  class Section::DebugStrOffsets < Section::Base
+    def get(base:, offset:, format:)
+      type = case format
+      when :dwarf32
+        CTypes::UInt32.with_endian(@file.endian)
+      when :dwarf64
+        CTypes::UInt64.with_endian(@file.endian)
+      else
+        raise Error, "unsupported format: %p" % [format]
+      end
+      pos = base + offset * type.size
+      type.unpack(bytes[pos..])
+    end
+  end
+end

data/lib/elf_utils/section/dynsym.rb

@@ -0,0 +1,14 @@
+require_relative "../symbol"
+
+module ElfUtils
+  class Section::Dynsym < Section::Base
+    def symbols
+      @symbols ||= begin
+        dynstr = @file.section(".dynstr")
+        @file.elf_type(:Sym).unpack_all(bytes).map do |sym|
+          Symbol.new(@file, sym, dynstr)
+        end
+      end
+    end
+  end
+end

data/lib/elf_utils/section/strtab.rb

@@ -0,0 +1,9 @@
+module ElfUtils
+  class Section::Strtab < Section::Base
+    def [](index)
+      @strings ||= bytes
+      str = @strings[index..].unpack1("Z*")
+      str.empty? ? nil : str
+    end
+  end
+end

data/lib/elf_utils/section/symtab.rb

@@ -0,0 +1,11 @@
+require_relative "../symbol"
+
+module ElfUtils
+  class Section::Symtab < Section::Base
+    def symbols
+      @symbols ||= @file.elf_type(:Sym).unpack_all(bytes).map do |sym|
+        Symbol.new(@file, sym)
+      end
+    end
+  end
+end

data/lib/elf_utils/section.rb

@@ -0,0 +1,50 @@
+module ElfUtils
+  module Section
+    def self.from_header(elf_file, header)
+      case header.sh_type
+      when :strtab
+        return Section::Strtab.new(elf_file, header)
+      when :symtab
+        return Section::Symtab.new(elf_file, header)
+      when :dynsym
+        return Section::Dynsym.new(elf_file, header)
+      end
+
+      name = elf_file.shstrtab[header.sh_name]
+      case name
+      when ".debug_info"
+        Section::DebugInfo.new(elf_file, header)
+      when ".debug_abbrev"
+        Section::DebugAbbrev.new(elf_file, header)
+      when ".debug_str"
+        Section::Strtab.new(elf_file, header)
+      when ".debug_str_offsets"
+        Section::DebugStrOffsets.new(elf_file, header)
+      when ".debug_aranges"
+        Section::DebugArange.new(elf_file, header)
+      when ".debug_line"
+        Section::DebugLine.new(elf_file, header)
+      when ".debug_line_str"
+        Section::Strtab.new(elf_file, header)
+      when ".debug_addr"
+        Section::DebugAddr.new(elf_file, header)
+      when ".debug_ranges"
+        Section::DebugRanges.new(elf_file, header)
+      else
+        Section::Base.new(elf_file, header)
+      end
+    end
+  end
+end
+
+require_relative "section/base"
+require_relative "section/strtab"
+require_relative "section/symtab"
+require_relative "section/dynsym"
+require_relative "section/debug_info"
+require_relative "section/debug_abbrev"
+require_relative "section/debug_str_offsets"
+require_relative "section/debug_arange"
+require_relative "section/debug_line"
+require_relative "section/debug_addr"
+require_relative "section/debug_ranges"

data/lib/elf_utils/segment/base.rb

@@ -0,0 +1,72 @@
+module ElfUtils
+  class Segment::Base
+    def initialize(file, header)
+      @file = file
+      @header = header
+      @offset = 0
+    end
+
+    def type
+      @header.p_type
+    end
+
+    def addr
+      @header.p_vaddr + @offset
+    end
+
+    def offset
+      @header.p_offset
+    end
+
+    def filesize
+      @header.p_filesz
+    end
+
+    def size
+      @header.p_memsz
+    end
+
+    def align
+      @header.p_align
+    end
+
+    def flags
+      @header.p_flags
+    end
+
+    def to_range
+      addr...(addr + size)
+    end
+
+    def inspect
+      @header.inspect
+    end
+
+    def sections
+      a = addr...(addr + size)
+      @file.sections.select do |section|
+        next unless section.alloc?
+        a.include?(section.addr) ||
+          a.include?(section.addr + section.size - 1)
+      end
+    end
+
+    # relocate this segement and all sections within it
+    #
+    # @param addr address for section; `nil` clears relocation
+    def relocate(addr)
+      if addr.nil?
+        sections.relocate(nil)
+        @offset = 0
+        return
+      end
+
+      # calculate the offset, then relocate the sections by that offset
+      offset = addr - @header.p_vaddr
+      sections.each do |section|
+        section.relocate(offset, relative: true)
+      end
+      @offset = offset
+    end
+  end
+end

data/lib/elf_utils/segment.rb

@@ -0,0 +1,9 @@
+module ElfUtils
+  module Segment
+    def self.from_header(elf_file, header)
+      Segment::Base.new(elf_file, header)
+    end
+  end
+end
+
+require_relative "segment/base"

data/lib/elf_utils/string_pread.rb

@@ -0,0 +1,18 @@
+module ElfUtils
+  # provide a #pread method for String
+  #
+  # This refinement is to allow String instances to be used as the underlying
+  # IO object for ElfFile.  Intended as a lighter-weight approach than
+  # IOString.
+  module StringPread
+    refine String do
+      # read up to `maxlen` bytes from the String starting at `offset`
+      # @param maxlen [Integer] maximum number of bytes to read
+      # @param offset [Integer] offset to begin reading at
+      # @return [String, nil] bytes read or nil
+      def pread(maxlen, offset)
+        byteslice(offset, maxlen)
+      end
+    end
+  end
+end