worf 1.0.0

data/test/dwarf_test.rb

@@ -0,0 +1,128 @@
+ENV["MT_NO_PLUGINS"] = "1"
+
+require "helper"
+
+module WORF
+  class Test < Minitest::Test
+    debug_file = "fixtures/out.dSYM/Contents/Resources/DWARF/out"
+    DEBUG_FILE = File.expand_path(File.join(__dir__, debug_file))
+
+    debug_file = "fixtures/a.out.dSYM/Contents/Resources/DWARF/a.out"
+    SLOP = File.expand_path(File.join(__dir__, debug_file))
+
+    def test_uleb128
+      assert_equal 624485, WORF.unpackULEB128(StringIO.new("\xE5\x8E\x26".b))
+    end
+
+    def test_sleb128
+      assert_equal(-123456, WORF.unpackSLEB128(StringIO.new("\xC0\xBB\x78".b)))
+    end
+
+    def test_debug_abbrev
+      File.open DEBUG_FILE do |io|
+        mach_o = OdinFlex::MachO.new(io)
+
+        section = mach_o.find do |thing|
+          thing.section? && thing.sectname == "__debug_abbrev"
+        end
+
+        debug_abbrev = WORF::DebugAbbrev.new io, section, mach_o.start_pos
+        tags = debug_abbrev.tags
+
+        assert_equal 5, tags.length
+      end
+    end
+
+    def test_debug_info
+      File.open DEBUG_FILE do |io|
+        mach_o = OdinFlex::MachO.new(io)
+
+        abbrev = mach_o.find do |thing|
+          thing.section? && thing.sectname == "__debug_abbrev"
+        end
+
+        debug_abbrev = WORF::DebugAbbrev.new io, abbrev, mach_o.start_pos
+
+        info = mach_o.find do |thing|
+          thing.section? && thing.sectname == "__debug_info"
+        end
+
+        debug_info = WORF::DebugInfo.new io, info, mach_o.start_pos
+        units = debug_info.compile_units(debug_abbrev.tags)
+
+        assert_equal 1, units.length
+        assert_equal Constants::DW_TAG_compile_unit, units.first.die.tag.type
+        assert_equal 0xb, units.first.die.offset
+        assert_equal 5, units.first.die.children.length
+        assert_equal Constants::DW_TAG_subprogram, units.first.die.children.first.tag.type
+        assert_equal 0x2a, units.first.die.children.first.offset
+      end
+    end
+
+    class StructInfo
+      def initialize die, names, ranges
+        @die    = die
+        @ranges = ranges
+      end
+
+      def byte_size; @die.byte_size; end
+
+      def used_size
+        @ranges.map(&:size).inject(:+)
+      end
+    end
+
+    def show unit, die, strings, dies
+      names = []
+      ranges = die.children.map do |child|
+        if child.tag.member?
+          type_die = dies.find { |d| d.offset == child.type }
+          size = if type_die.tag.pointer_type?
+                   unit.address_size
+                 else
+                   type_die.byte_size
+                 end
+          start = child.data_member_location
+          name = strings.string_at(child.name_offset)
+          names << name
+          Range.new(start, start + size, exclude_end: true)
+        else
+          raise NotImplementedError
+        end
+      end
+
+      StructInfo.new die, names, ranges
+    end
+
+    def test_read_struct
+      struct_info = nil
+
+      File.open SLOP do |io|
+        mach_o = OdinFlex::MachO.new(io)
+
+        abbrev = mach_o.find_section "__debug_abbrev"
+        debug_abbrev = WORF::DebugAbbrev.new io, abbrev, mach_o.start_pos
+
+        section_info = mach_o.find_section "__debug_str"
+        strings = WORF::DebugStrings.new io, section_info, mach_o.start_pos
+
+        info = mach_o.find_section "__debug_info"
+        debug_info = WORF::DebugInfo.new io, info, mach_o.start_pos
+
+        units = debug_info.compile_units(debug_abbrev.tags)
+
+        units.each do |unit|
+          unit.die.children.each do |die|
+            if die.tag.structure_type?
+              struct_info = show unit, die, strings, unit.die.to_a
+              break
+            end
+          end
+        end
+      end
+
+      assert_equal 24, struct_info.byte_size
+      assert_equal 17, struct_info.used_size
+    end
+  end
+end

data/test/fixtures/a.out.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.a.out</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

data/test/fixtures/out.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.out</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

data/test/fixtures/slop.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+struct hello {
+    char *p;
+    char c;
+    long x;
+};
+
+int main(int argc, char **argv) {
+  struct hello * m;
+  m = malloc(sizeof(struct hello));
+  m->c = 123;
+  m->x = 123;
+  printf("Hello World %lu\n", m->x);
+  return 0;
+}

data/test/fixtures/thing.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main(int argc, char **argv) {
+  printf("Hello World\n");
+  return 0;
+}

data/test/helper.rb

@@ -0,0 +1,59 @@
+ENV["MT_NO_PLUGINS"] = "1"
+
+require "minitest/autorun"
+require "worf"
+require "odinflex/mach-o"
+require "odinflex/ar"
+require "rbconfig"
+require "fiddle"
+
+module WORF
+  class Test < Minitest::Test
+    include Fiddle
+
+    module Hacks
+      include Fiddle
+
+      class Fiddle::Function
+        def to_proc
+          this = self
+          lambda { |*args| this.call(*args) }
+        end
+      end unless Function.method_defined?(:to_proc)
+
+      def self.make_function name, args, ret
+        ptr = Handle::DEFAULT[name]
+        func = Function.new ptr, args, ret, name: name
+        define_singleton_method name, &func.to_proc
+      end
+
+      make_function "strerror", [TYPE_INT], TYPE_CONST_STRING
+      #make_function "mprotect", [TYPE_VOIDP, TYPE_SIZE_T, TYPE_INT], TYPE_INT
+      make_function "_dyld_image_count", [], TYPE_INT32_T
+      make_function "_dyld_get_image_name", [TYPE_INT32_T], TYPE_CONST_STRING
+      make_function "_dyld_get_image_vmaddr_slide", [TYPE_INT32_T], TYPE_INTPTR_T
+      make_function "mach_task_self", [], TYPE_VOIDP
+      make_function "vm_protect", [TYPE_VOIDP, -TYPE_INT64_T, TYPE_SIZE_T, TYPE_CHAR, TYPE_INT], TYPE_INT
+      make_function "rb_intern", [TYPE_CONST_STRING], TYPE_INT
+
+      def self.mprotect addr, len, prot
+        vm_protect mach_task_self, addr, len, 0, prot | PROT_COPY
+      end
+
+      PROT_READ   = 0x01
+      PROT_WRITE  = 0x02
+      PROT_EXEC   = 0x04
+      PROT_COPY   = 0x10
+
+      def self.slide
+        executable = RbConfig.ruby
+        Hacks._dyld_image_count.times do |i|
+          name = Hacks._dyld_get_image_name(i)
+          if executable == name
+            return Hacks._dyld_get_image_vmaddr_slide(i)
+          end
+        end
+      end
+    end
+  end
+end

data/test/mach_o_dwarf_integration_test.rb

@@ -0,0 +1,52 @@
+require "helper"
+
+module WORF
+  class MachODWARFIntegrationTest < Test
+    def test_find_symbol_and_make_struct
+      addr = nil
+      archive = nil
+
+      File.open(RbConfig.ruby) do |f|
+        my_macho = OdinFlex::MachO.new f
+        my_macho.each do |section|
+          if section.symtab?
+            addr = section.nlist.find { |symbol|
+              symbol.name == "_ruby_api_version" && symbol.value > 0
+            }.value + Hacks.slide
+
+            archive = section.nlist.find_all(&:archive?).map(&:archive).uniq.first
+          end
+        end
+      end
+
+      assert addr
+      assert archive
+
+      found_object = nil
+
+      File.open(archive) do |f|
+        ar = OdinFlex::AR.new f
+        ar.each do |object_file|
+          next unless object_file.identifier.end_with?(".o")
+          next unless object_file.identifier == "version.o"
+
+          f.seek object_file.pos, IO::SEEK_SET
+          macho = OdinFlex::MachO.new f
+          debug_info = macho.find_section("__debug_info")&.as_dwarf || next
+          debug_strs = macho.find_section("__debug_str").as_dwarf
+          debug_abbrev = macho.find_section("__debug_abbrev").as_dwarf
+
+          debug_info.compile_units(debug_abbrev.tags).each do |unit|
+            unit.die.children.each do |die|
+              if die.name(debug_strs) == "ruby_api_version"
+                found_object = object_file
+              end
+            end
+          end
+        end
+      end
+
+      assert found_object
+    end
+  end
+end

data/test/ruby_test.rb

@@ -0,0 +1,238 @@
+require "helper"
+
+module WORF
+  class RubyTest < WORF::Test
+    def ruby_archive
+      File.join RbConfig::CONFIG["prefix"], "lib", RbConfig::CONFIG["LIBRUBY"]
+    end
+
+    def test_ruby_archive
+      assert File.file?(ruby_archive)
+    end
+
+    def test_read_archive
+      files = []
+      File.open(ruby_archive) do |f|
+        OdinFlex::AR.new(f).each { |file| files << file.identifier }
+      end
+      assert_includes files, "gc.o"
+    end
+
+    def test_read_archive_twice
+      files = []
+      File.open(ruby_archive) do |f|
+        ar = OdinFlex::AR.new(f)
+        ar.each { |file| files << file.identifier }
+        assert_includes files, "gc.o"
+        files.clear
+        ar.each { |file| files << file.identifier }
+        assert_includes files, "gc.o"
+      end
+    end
+
+    def test_macho_in_archive
+      File.open(ruby_archive) do |f|
+        ar = OdinFlex::AR.new f
+        gc = ar.find { |file| file.identifier == "gc.o" }
+
+        f.seek gc.pos, IO::SEEK_SET
+        macho = OdinFlex::MachO.new f
+        section = macho.find_section("__debug_str")
+        assert_equal "__debug_str", section.sectname
+      end
+    end
+
+    def test_macho_to_dwarf
+      File.open(ruby_archive) do |f|
+        ar = OdinFlex::AR.new f
+        gc = ar.find { |file| file.identifier == "gc.o" }
+
+        f.seek gc.pos, IO::SEEK_SET
+        macho = OdinFlex::MachO.new f
+        debug_strs = macho.find_section("__debug_str").as_dwarf
+        debug_abbrev = macho.find_section("__debug_abbrev").as_dwarf
+        debug_info = macho.find_section("__debug_info").as_dwarf
+
+        names = []
+
+        debug_info.compile_units(debug_abbrev.tags).each do |unit|
+          unit.die.children.each do |die|
+            names << die.name(debug_strs)
+          end
+        end
+
+        assert_includes names, "RBasic"
+      end
+    end
+
+    def test_rbasic_layout
+      File.open(ruby_archive) do |f|
+        ar = OdinFlex::AR.new f
+        gc = ar.find { |file| file.identifier == "gc.o" }
+
+        f.seek gc.pos, IO::SEEK_SET
+        macho = OdinFlex::MachO.new f
+        debug_strs = macho.find_section("__debug_str").as_dwarf
+        debug_abbrev = macho.find_section("__debug_abbrev").as_dwarf
+        debug_info = macho.find_section("__debug_info").as_dwarf
+
+        rbasic_layout = []
+
+        debug_info.compile_units(debug_abbrev.tags).each do |unit|
+          unit.die.children.each do |die|
+            if die.name(debug_strs) == "RBasic"
+              assert_predicate die.tag, :structure_type?
+
+              die.children.each do |child|
+                field_name = child.name(debug_strs)
+                field_type = nil
+                while child
+                  field_type = child.name(debug_strs)
+                  break unless child.type
+                  child = unit.die.find_type(child)
+                end
+                rbasic_layout << [field_name, field_type]
+              end
+            end
+          end
+        end
+
+        assert_equal([["flags", "long unsigned int"], ["klass", "long unsigned int"]],
+                     rbasic_layout)
+      end
+    end
+
+    def test_rclass_layout
+      File.open(ruby_archive) do |f|
+        ar = OdinFlex::AR.new f
+        gc = ar.find { |file| file.identifier == "gc.o" }
+
+        f.seek gc.pos, IO::SEEK_SET
+        macho = OdinFlex::MachO.new f
+        debug_strs = macho.find_section("__debug_str").as_dwarf
+        debug_abbrev = macho.find_section("__debug_abbrev").as_dwarf
+        debug_info = macho.find_section("__debug_info").as_dwarf
+
+        layout = []
+
+        debug_info.compile_units(debug_abbrev.tags).each do |unit|
+          unit.die.children.each do |die|
+            if die.name(debug_strs) == "RClass"
+              assert_predicate die.tag, :structure_type?
+
+              die.children.each do |child|
+                field_name = child.name(debug_strs)
+                type = unit.die.find_type(child)
+
+                if type.tag.typedef?
+                  type = unit.die.find_type(type)
+                end
+
+                type_name = if type.tag.pointer_type?
+                  c = unit.die.find_type(type)
+                  "#{c.name(debug_strs)} *"
+                else
+                  type.name(debug_strs)
+                end
+
+                type_size = if type.tag.pointer_type?
+                              unit.address_size
+                            else
+                              type.byte_size
+                            end
+
+                layout << [field_name, type_name, type_size]
+              end
+            end
+          end
+        end
+
+        assert_equal([["basic", "RBasic", 16],
+                      ["super", "long unsigned int", 8],
+                      ["ptr", "rb_classext_struct *", 8],
+                      ["class_serial", "long long unsigned int", 8]],
+                     layout)
+      end
+    end
+
+    [
+      [:section?, OdinFlex::MachO::Section],
+      [:symtab?, OdinFlex::MachO::LC_SYMTAB],
+      [:segment?, OdinFlex::MachO::LC_SEGMENT_64],
+      [:dysymtab?, OdinFlex::MachO::LC_DYSYMTAB],
+      [:command?, OdinFlex::MachO::Command],
+    ].each do |predicate, klass|
+      define_method :"test_find_#{predicate}" do
+        File.open(RbConfig.ruby) do |f|
+          my_macho = OdinFlex::MachO.new f
+          list = my_macho.find_all(&predicate)
+          refute_predicate list, :empty?
+          assert list.all? { |x| x.is_a?(klass) }
+        end
+      end
+    end
+
+    def test_rb_vm_get_insns_address_table
+      sym = nil
+
+      File.open(RbConfig.ruby) do |f|
+        my_macho = OdinFlex::MachO.new f
+
+        my_macho.each do |section|
+          if section.symtab?
+            sym = section.nlist.find do |symbol|
+              symbol.name == "_rb_vm_get_insns_address_table" && symbol.value
+            end
+            break if sym
+          end
+        end
+      end
+
+      addr = sym.value + Hacks.slide
+      ptr = Fiddle::Function.new(addr, [], TYPE_VOIDP).call
+      len = RubyVM::INSTRUCTION_NAMES.length
+      assert ptr[0, len * Fiddle::SIZEOF_VOIDP].unpack("Q#{len}")
+    end
+
+    def test_guess_slide
+      File.open(RbConfig.ruby) do |f|
+        my_macho = OdinFlex::MachO.new f
+
+        my_macho.each do |section|
+          if section.symtab?
+            section.nlist.each do |symbol|
+              if symbol.name == "_rb_st_insert"
+                guess_slide = Fiddle::Handle::DEFAULT["rb_st_insert"] - symbol.value
+                assert_equal Hacks.slide, guess_slide
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def test_find_global
+      File.open(RbConfig.ruby) do |f|
+        my_macho = OdinFlex::MachO.new f
+
+        my_macho.each do |section|
+          if section.symtab?
+            section.nlist.each do |symbol|
+              if symbol.name == "_ruby_api_version"
+                if symbol.value > 0
+                  addr = symbol.value + Hacks.slide
+                  pointer = Fiddle::Pointer.new(addr, Fiddle::SIZEOF_INT * 3)
+                  assert_equal RbConfig::CONFIG["ruby_version"].split(".").map(&:to_i),
+                    pointer[0, Fiddle::SIZEOF_INT * 3].unpack("LLL")
+                else
+                  assert_predicate symbol, :stab?
+                  assert_predicate symbol, :gsym?
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end