elf_utils 0.3.0

data/lib/elf_utils/types/dwarf32/v4.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "ctypes"
+
+module ElfUtils::Types::Dwarf32::V4
+  extend CTypes::Helpers
+
+  class CU_Header < CTypes::Struct # standard:disable Naming/ClassAndModuleCamelCase
+    layout do
+      attribute :unit_length, uint32
+      attribute :version, uint16
+      attribute :debug_abbrev_offset, uint32
+      attribute :addr_size, uint8
+      attribute :data, string(trim: false)
+      size { |h| offsetof(:version) + h[:unit_length] }
+    end
+
+    def format
+      :dwarf32
+    end
+  end
+
+  class LineNumberProgramHeader < CTypes::Struct
+    layout do
+      attribute :unit_length, uint32
+      attribute :version, uint16
+      attribute :header_length, uint32
+      attribute :minimum_instruction_length, uint8
+      attribute :maximum_operations_per_instruction, uint8
+      attribute :default_is_stmt, uint8
+      attribute :line_base, int8
+      attribute :line_range, uint8
+      attribute :opcode_base, uint8
+      attribute :_rest, string(trim: false)
+    end
+
+    def addr_type
+      CTypes::Helpers.uint32.with_endian(@endian)
+    end
+  end
+end

data/lib/elf_utils/types/dwarf32/v5.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "ctypes"
+
+module ElfUtils::Types::Dwarf32::V5
+  extend CTypes::Helpers
+
+  class CU_Header < CTypes::Struct # standard:disable Naming/ClassAndModuleCamelCase
+    layout do
+      attribute :unit_length, uint32
+      attribute :version, uint16
+      attribute :unit_type, uint8
+      attribute :addr_size, uint8
+      attribute :debug_abbrev_offset, uint32
+      attribute :data, string(trim: false)
+      size { |h| offsetof(:version) + h[:unit_length] }
+    end
+
+    def format
+      :dwarf32
+    end
+  end
+
+  class LineNumberProgramHeader < CTypes::Struct
+    layout do
+      attribute :unit_length, uint32
+      attribute :version, uint16
+      attribute :address_size, uint8
+      attribute :segment_selector_size, uint8
+      attribute :header_length, uint32
+      attribute :minimum_instruction_length, uint8
+      attribute :maximum_operations_per_instruction, uint8
+      attribute :default_is_stmt, uint8
+      attribute :line_base, int8
+      attribute :line_range, uint8
+      attribute :opcode_base, uint8
+      attribute :_rest, string(trim: false)
+    end
+
+    def addr_type
+      CTypes::Helpers.uint32.with_endian(@endian)
+    end
+  end
+end

data/lib/elf_utils/types/dwarf32.rb

@@ -0,0 +1,12 @@
+require_relative "dwarf"
+
+module ElfUtils
+  module Types::Dwarf32
+    extend Types::Dwarf
+  end
+end
+
+require_relative "dwarf32/v2"
+require_relative "dwarf32/v3"
+require_relative "dwarf32/v4"
+require_relative "dwarf32/v5"

data/lib/elf_utils/types/dwarf64/v3.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "ctypes"
+
+module ElfUtils::Types::Dwarf64::V3
+  extend CTypes::Helpers
+
+  class CU_Header < CTypes::Struct # standard:disable Naming/ClassAndModuleCamelCase
+    layout do
+      attribute :_dw64_flag, uint32
+      attribute :unit_length, uint64
+      attribute :version, uint16
+      attribute :debug_abbrev_offset, uint64
+      attribute :addr_size, uint8
+      attribute :data, string(trim: false)
+      size { |h| offsetof(:version) + h[:unit_length] }
+    end
+
+    def format
+      :dwarf64
+    end
+  end
+
+  class LineNumberProgramHeader < CTypes::Struct
+    layout do
+      attribute :_marker, uint32
+      attribute :unit_length, uint64
+      attribute :version, uint16
+      attribute :header_length, uint64
+      attribute :minimum_instruction_length, uint8
+      attribute :default_is_stmt, uint8
+      attribute :line_base, int8
+      attribute :line_range, uint8
+      attribute :opcode_base, uint8
+      attribute :_rest, string(trim: false)
+    end
+
+    def addr_type
+      CTypes::Helpers.uint64.with_endian(@endian)
+    end
+  end
+end

data/lib/elf_utils/types/dwarf64/v4.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "ctypes"
+
+module ElfUtils::Types::Dwarf64::V4
+  extend CTypes::Helpers
+
+  class CU_Header < CTypes::Struct # standard:disable Naming/ClassAndModuleCamelCase
+    layout do
+      attribute :_dw64_flag, uint32
+      attribute :unit_length, uint64
+      attribute :version, uint16
+      attribute :debug_abbrev_offset, uint64
+      attribute :addr_size, uint8
+      attribute :data, string(trim: false)
+      size { |h| offsetof(:version) + h[:unit_length] }
+    end
+
+    def format
+      :dwarf64
+    end
+  end
+
+  class LineNumberProgramHeader < CTypes::Struct
+    layout do
+      attribute :_marker, uint32
+      attribute :unit_length, uint64
+      attribute :version, uint16
+      attribute :header_length, uint64
+      attribute :minimum_instruction_length, uint8
+      attribute :maximum_operations_per_instruction, uint8
+      attribute :default_is_stmt, uint8
+      attribute :line_base, int8
+      attribute :line_range, uint8
+      attribute :opcode_base, uint8
+      attribute :_rest, string(trim: false)
+    end
+
+    def addr_type
+      CTypes::Helpers.uint64.with_endian(@endian)
+    end
+  end
+end

data/lib/elf_utils/types/dwarf64/v5.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "ctypes"
+
+module ElfUtils::Types::Dwarf64::V5
+  extend CTypes::Helpers
+
+  class CU_Header < CTypes::Struct # standard:disable Naming/ClassAndModuleCamelCase
+    layout do
+      attribute :_dw64_flag, uint32
+      attribute :unit_length, uint64
+      attribute :version, uint16
+      attribute :unit_type, uint8
+      attribute :addr_size, uint8
+      attribute :debug_abbrev_offset, uint64
+      attribute :data, string(trim: false)
+      size { |h| offsetof(:version) + h[:unit_length] }
+    end
+
+    def format
+      :dwarf64
+    end
+  end
+
+  class LineNumberProgramHeader < CTypes::Struct
+    layout do
+      attribute :_marker, uint32
+      attribute :unit_length, uint64
+      attribute :version, uint16
+      attribute :address_size, uint8
+      attribute :segment_selector_size, uint8
+      attribute :header_length, uint64
+      attribute :minimum_instruction_length, uint8
+      attribute :maximum_operations_per_instruction, uint8
+      attribute :default_is_stmt, uint8
+      attribute :line_base, int8
+      attribute :line_range, uint8
+      attribute :opcode_base, uint8
+      attribute :_rest, string(trim: false)
+    end
+
+    def addr_type
+      CTypes::Helpers.uint64.with_endian(@endian)
+    end
+  end
+end

data/lib/elf_utils/types/dwarf64.rb

@@ -0,0 +1,8 @@
+module ElfUtils
+  module Types::Dwarf64
+  end
+end
+
+require_relative "dwarf64/v3"
+require_relative "dwarf64/v4"
+require_relative "dwarf64/v5"

data/lib/elf_utils/types/sleb128.rb

@@ -0,0 +1,66 @@
+# encoding: ASCII-8BIT
+# frozen_string_literal: true
+
+require "ctypes"
+
+module ElfUtils::Types::SLEB128
+  extend CTypes::Type
+
+  # declare the underlying DRY type; it must have a default value, and may
+  # have constraints set
+  @dry_type = Dry::Types["integer"].default(0)
+
+  # as this is a dynamically sized type, let's set size to be the minimum size
+  # for the type (1 byte), and ensure .fixed_size? returns false
+  @size = 1
+  def self.fixed_size?
+    false
+  end
+
+  def self.size
+    @size
+  end
+
+  # provide a method for packing the ruby value into the binary representation
+  def self.pack(value, endian: default_endian, validate: true)
+    return "\0" if value == 0
+    buf = +""
+    done = false
+    until done
+      byte = (value & 0x7f)
+      value >>= 7
+      signed = byte & 0x40 != 0
+
+      if (value == 0 && !signed) || (value == -1 && signed)
+        done = true
+      else
+        byte |= 0x80
+      end
+
+      buf << byte
+    end
+
+    buf
+  end
+
+  # provide a method for unpacking an instance of this type from a String, and
+  # returning both the unpacked value, and any unused input
+  def self.unpack_one(buf, endian: default_endian)
+    value = 0
+    shift = 0
+    len = 0
+    terminated, sign_extend = buf.each_byte do |b|
+      len += 1
+      value |= ((b & 0x7f) << shift)
+      shift += 7
+      if (b & 0x80) == 0
+        break [true, b & 0x40 != 0]
+      end
+    end
+    raise TerminatorNotFoundError unless terminated
+
+    value |= (~0 << shift) if sign_extend
+
+    [value, buf.byteslice(len..)]
+  end
+end

data/lib/elf_utils/types/uleb128.rb

@@ -0,0 +1,56 @@
+# encoding: ASCII-8BIT
+# frozen_string_literal: true
+
+require "ctypes"
+require "elf_utils/elf_utils" ## for unpack_one
+
+module ElfUtils::Types::ULEB128
+  extend CTypes::Type
+
+  # declare the underlying DRY type; it must have a default value, and may
+  # have constraints set
+  @dry_type = Dry::Types["integer"].default(0)
+
+  # as this is a dynamically sized type, let's set size to be the minimum size
+  # for the type (1 byte), and ensure .fixed_size? returns false
+  @size = 1
+  def self.fixed_size?
+    false
+  end
+
+  def self.size
+    @size
+  end
+
+  def self.greedy?
+    false
+  end
+
+  # provide a method for packing the ruby value into the binary representation
+  def self.pack(value, endian: default_endian, validate: true)
+    return "\0" if value == 0
+    buf = +""
+    while value != 0
+      byte = (value & 0x7f)
+      value >>= 7
+      byte |= 0x80 if value != 0
+      buf << byte
+    end
+    buf
+  end
+
+  # provide a method for unpacking an instance of this type from a String, and
+  # returning both the unpacked value, and any unused input
+  def self.unpack_one_ruby(buf, endian: default_endian)
+    value = 0
+    shift = 0
+    len = 0
+    buf.each_byte do |b|
+      len += 1
+      value |= ((b & 0x7f) << shift)
+      return value, buf.byteslice(len...) if (b & 0x80) == 0
+      shift += 7
+    end
+    raise TerminatorNotFoundError
+  end
+end

data/lib/elf_utils/types/unit_length.rb

@@ -0,0 +1,51 @@
+# encoding: ASCII-8BIT
+# frozen_string_literal: true
+
+require "ctypes"
+
+module ElfUtils::Types::UnitLength
+  extend CTypes::Type
+
+  # declare the underlying DRY type; it must have a default value, and may
+  # have constraints set
+  @dry_type = Dry::Types["integer"].default(0)
+
+  # as this is a dynamically sized type, let's set size to be the minimum size
+  # for the type (1 byte), and ensure .fixed_size? returns false
+  @size = 4
+  def self.fixed_size?
+    false
+  end
+
+  def self.size
+    @size
+  end
+
+  # provide a method for packing the ruby value into the binary representation
+  def self.pack(value, endian: default_endian, validate: true)
+    return "\0" if value == 0
+    buf = +""
+    while value != 0
+      byte = (value & 0x7f)
+      value >>= 7
+      byte |= 0x80 if value != 0
+      buf << byte
+    end
+    buf
+  end
+
+  # provide a method for unpacking an instance of this type from a String, and
+  # returning both the unpacked value, and any unused input
+  def self.unpack_one(buf, endian: default_endian)
+    value = 0
+    shift = 0
+    len = 0
+    buf.each_byte do |b|
+      len += 1
+      value |= ((b & 0x7f) << shift)
+      return value, buf.byteslice(len...) if (b & 0x80) == 0
+      shift += 7
+    end
+    raise TerminatorNotFoundError
+  end
+end