dwarftree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1cbf8325c9c3f5a37a6a0db7c15291ae52269ef3555e669c087f01079ca7fd6b
+  data.tar.gz: 5ce3c1fd1da182a3747cc6fdfad54287939e8c7ae49b4788cec65a474fd4563b
+SHA512:
+  metadata.gz: b564269e0d418225f1fe2a66aa5e9a3589ec6307c47592d2bc4393f20693b8540149628445cad3c3addaa5f3f9eec270a75d5a455d41e4415eef587f691eee1c
+  data.tar.gz: 2b94b9c633e312d751fdb9a3423f0d5359628ed3d3643978564dd1a38dbbe61225ca0c5133557956cf515ee41f78d4265f051fe28f5771f62a0130fccd4ec593

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in dwarftree.gemspec
+gemspec
+
+gem "rake"
+gem "pry"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Takashi Kokubun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,113 @@
+# Dwarftree
+
+A wrapper of `objdump --dwarf=info` to visualize an object's structure and show code size
+
+## Installation
+
+Prepare Ruby 2.6+, and
+
+```bash
+$ gem install dwarftree
+```
+
+## Usage
+First, make sure your object file has debug symbols (dwarf) and you have `objdump`.
+
+### Dump all entries
+
+```bash
+$ dwarftree /tmp/_ruby_mjit_p30080u145.so
+compile_unit (name: /tmp/_ruby_mjit_p16698u145.c)
+  base_type (byte_size: 8, encoding: 4  (float), name: double)
+  base_type (byte_size: 8, encoding: 5  (signed), name: long int)
+  ...
+  subprogram (name: _mjit102_sinatra_base_rb_force_encoding)
+    ...
+    lexical_block (ranges: [223864..223982, 224056..224327, 224597..224624, 224704..224720, 224768..224784, 224840..224848, 224880..224896, 224928..225059], sibling: <0x6d3a>)
+      variable (name: cc, decl_file: 99, decl_line: 26, type: variable, const_value: 0x55d561e7f3b0)
+      variable (name: cc_cme, decl_file: 99, decl_line: 27, type: variable, const_value: 0x55d561ac71a0)
+      lexical_block (ranges: [224103..224116, 224132..224317, 224597..224624, 224840..224848, 224928..224952, 224976..225059], sibling: <0x6c86>)
+        variable (name: val, decl_file: 99, decl_line: 37, type: variable, location: 0x6fb8 (location list))
+        variable (name: calling, decl_file: 99, decl_line: 38, type: variable, location: 0x7014 (location list))
+        inlined_subroutine (abstract_origin: vm_call_iseq_setup_normal)
+          formal_parameter (type: formal_parameter, location: 0x718a (location list), abstract_origin: local_size)
+          formal_parameter (type: formal_parameter, location: 0x718a (location list), abstract_origin: param_size)
+  ...
+```
+
+### Dump a single subprogram
+
+```bash
+$ dwarftree /tmp/_ruby_mjit_p16698u145.so -S _mjit102_sinatra_base_rb_force_encoding
+subprogram (name: _mjit102_sinatra_base_rb_force_encoding)
+  formal_parameter (name: ec, decl_file: 99, decl_line: 8, type: formal_parameter, location: 0x6c82 (location list))
+  formal_parameter (name: reg_cfp, decl_file: 99, decl_line: 8, type: formal_parameter, location: 0x6d8c (location list))
+  variable (name: stack, decl_file: 99, decl_line: 10, type: variable, location: 0x6e13 (location list))
+  variable (name: original_iseq, decl_file: 99, decl_line: 11, type: variable, const_value: 0x55d5616ff108)
+  variable (name: original_body_iseq, decl_file: 99, decl_line: 12, type: variable, const_value: 0x55d5619a74f0)
+  label (name: label_0, decl_file: 99, decl_line: 14, low_pc: 0x36a60)
+  label (name: label_1, decl_file: 99, decl_line: 24, low_pc: 0x36a78)
+  label (name: send_cancel, decl_file: 99, decl_line: 132, low_pc: 0x36aee)
+  label (name: cancel, decl_file: 99, decl_line: 150, low_pc: 0x36b17)
+  ...
+  label (name: ivar_cancel, decl_file: 99, decl_line: 138)
+  label (name: exivar_cancel, decl_file: 99, decl_line: 144)
+  lexical_block (low_pc: 0x36a74, high_pc: 0x4, sibling: <0x69e7>)
+    variable (name: stack_size, decl_file: 99, decl_line: 16, type: variable, const_value: 0)
+    variable (name: val, decl_file: 99, decl_line: 17, type: variable, location: 0x6f23 (location list))
+  ...
+```
+
+### Sort subprograms by code size
+
+```bash
+$ dwarftree /tmp/_ruby_mjit_p16698u145.so --show-size --sort-size --die subprogram
+subprogram size=12.0K (name: _mjit95_sinatra_base_rb_process_route)
+subprogram size=6.4K (name: _mjit133_logger_rb_level_)
+subprogram size=6.3K (name: _mjit85_rack_request_rb_POST)
+subprogram size=4.9K (name: setup_parameters_complex)
+subprogram size=3.9K (name: _mjit43_rack_method_override_rb_call)
+subprogram size=3.6K (name: _mjit63_rack_protection_path_traversal_rb_cleanup)
+subprogram size=3.6K (name: _mjit64_rack_protection_xss_header_rb_call)
+subprogram size=3.5K (name: _mjit14_sinatra_base_rb_body)
+subprogram size=3.2K (name: _mjit81_rack_query_parser_rb_parse_nested_query)
+subprogram size=3.1K (name: _mjit56_logger_log_device_rb_set_dev)
+subprogram size=3.1K (name: _mjit78_rack_request_rb_GET)
+subprogram size=3.0K (name: _mjit51_logger_rb_initialize)
+subprogram size=3.0K (name: _mjit143_sinatra_base_rb_invoke)
+...
+```
+
+### Inspect code size of inlined subroutines
+
+```bash
+$ dwarftree /tmp/_ruby_mjit_p16698u145.so -S _mjit102_sinatra_base_rb_force_encoding --show-size --sort-size --die inlined_subroutine
+subprogram size=1.2K (name: _mjit102_sinatra_base_rb_force_encoding)
+  inlined_subroutine size=536 (abstract_origin: vm_sendish)
+    inlined_subroutine size=34 (abstract_origin: mjit_exec)
+    inlined_subroutine size=14 (abstract_origin: vm_ci_argc)
+      inlined_subroutine size=8 (abstract_origin: vm_ci_packed_p)
+    inlined_subroutine size=6 (abstract_origin: vm_ci_flag)
+    inlined_subroutine size=4 (abstract_origin: VM_ENV_FLAGS_SET)
+    inlined_subroutine size=4 (abstract_origin: VM_ENV_FLAGS_SET)
+  inlined_subroutine size=342 (abstract_origin: mjit_exec)
+    inlined_subroutine size=29 (abstract_origin: mjit_target_iseq_p)
+  inlined_subroutine size=264 (abstract_origin: vm_call_iseq_setup_normal)
+    inlined_subroutine size=206 (abstract_origin: vm_push_frame)
+  inlined_subroutine size=173 (abstract_origin: rb_class_of)
+    inlined_subroutine size=15 (abstract_origin: RB_SPECIAL_CONST_P)
+    inlined_subroutine size=4 (abstract_origin: RBASIC_CLASS)
+  inlined_subroutine size=106 (abstract_origin: vm_splat_array)
+  inlined_subroutine size=29 (abstract_origin: vm_cc_valid_p)
+  inlined_subroutine size=4 (abstract_origin: VM_ENV_FLAGS_SET)
+```
+
+## Project status
+
+It works well on my x86\_64 Ubuntu 18.04 environment, but they aren't tested in other environments.
+
+As I originally wanted to dig into only `subprogram` and `inlined_subroutine`, other DIEs have not been formatted well yet.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dwarftree"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dwarftree.gemspec

@@ -0,0 +1,21 @@
+require_relative 'lib/dwarftree/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dwarftree'
+  spec.version       = Dwarftree::VERSION
+  spec.authors       = ['Takashi Kokubun']
+  spec.email         = ['takashikkbn@gmail.com']
+
+  spec.summary       = %q{A wrapper of `objdump --dwarf=info` to visualize a structure of inlined subroutines}
+  spec.description   = %q{A wrapper of `objdump --dwarf=info` to visualize a structure of inlined subroutines}
+  spec.homepage      = 'https://github.com/k0kubun/dwarftree'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+end

data/exe/dwarftree

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'dwarftree'
+require 'optparse'
+require 'set'
+
+subprograms = Set.new
+dies = Set.new
+show_size = false
+sort_size = false
+
+objects = OptionParser.new do |o|
+  o.banner = "Usage: #{$0} OBJECT"
+  o.on('-S', '--subprogram NAME1,NAME2,...', String, 'Show only specified subprograms and their children') do |ss|
+    ss.split(',').each { |s| subprograms.add(s) }
+  end
+  o.on('--die TAG1,TAG2,...', String, 'Show only specified DIEs') do |ds|
+    ds.split(',').each { |d| dies.add(d) }
+  end
+  o.on('--show-size', 'Show code size for DIEs which have the information') do
+    show_size = true
+  end
+  o.on('--sort-size', 'Show code size and sort sibling DIEs by it') do
+    show_size = true
+    sort_size = true
+  end
+end.parse!(ARGV)
+
+objects.each do |object|
+  Dwarftree.run(object, dies: dies, subprograms: subprograms, show_size: show_size, sort_size: sort_size)
+end

data/lib/dwarftree/debug_info_parser.rb

@@ -0,0 +1,146 @@
+require 'dwarftree/debug_ranges_parser'
+require 'dwarftree/die'
+require 'strscan'
+
+class Dwarftree::DebugInfoParser
+  CommandError = Class.new(StandardError)
+  ParserError = Class.new(StandardError)
+
+  using Module.new {
+    refine StringScanner do
+      def scan!(pattern)
+        scan(pattern).tap do |result|
+          if result.nil?
+            raise ParserError.new("Expected #{pattern.inspect} but got: #{rest}")
+          end
+        end
+      end
+    end
+  }
+
+  def self.parse(object)
+    begin
+      offset_ranges = Dwarftree::DebugRangesParser.parse(object)
+    rescue Dwarftree::DebugRangesParser::CommandError => e
+      raise CommandError.new(e.message)
+    end
+
+    cmd = ['objdump', '--dwarf=info', object]
+    debug_info = IO.popen(cmd, &:read)
+    unless $?.success?
+      raise CommandError.new("Failed to run: #{cmd.join(' ')}")
+    end
+    new(offset_ranges).parse(debug_info)
+  end
+
+  def initialize(offset_ranges)
+    @offset_die = {} # { 12345 => #<Dwarftree::DIE:* ...> }
+    @offset_ranges = offset_ranges # { 12345 => [(12345..67890), ...] }
+  end
+
+  # @param [String] debug_info
+  # @return [Array<Dwarftree::DIE::CompileUnit>]
+  def parse(debug_info)
+    compile_units = []
+    each_compilation_unit(debug_info) do |compilation_unit|
+      compile_units << parse_compilation_unit(compilation_unit)
+    end
+    compile_units
+  end
+
+  private
+
+  # @param [String] debug_info
+  def each_compilation_unit(debug_info)
+    compilation_units = debug_info.split(/^  Compilation Unit @ offset 0x\h+:\n/)
+    compilation_units.drop(1).each do |compilation_unit|
+      dies = compilation_unit.sub!(/\A(   [^:]+: [^\n]+\n)+/, '')
+      if dies.nil?
+        raise ParserError.new("Expected Compilation Unit to have attributes but got: #{dies}")
+      end
+      yield(dies)
+    end
+  end
+
+  # @param [String] compilation_unit
+  def parse_compilation_unit(compilation_unit)
+    dies = []
+    each_die(compilation_unit) do |die|
+      if parsed = parse_die(die)
+        dies << parsed
+      end
+    end
+    dies.each do |die|
+      resolve_references(die)
+      die.freeze
+    end
+    build_tree(dies)
+  end
+
+  # @param [String] dies
+  def each_die(dies, &block)
+    dies.scan(/^ <\d+><\h+>:[^\n]+\n(?:    <\h+> [^\n]+\n)*/, &block)
+  end
+
+  # @param [String] die
+  def parse_die(die)
+    scanner = StringScanner.new(die)
+
+    scanner.scan!(/ <(?<level>\d+)><(?<offset>\h+)>: Abbrev Number: (\d+ \(DW_TAG_(?<type>[^\)]+)\)|0)\n/)
+    level, offset, type = scanner[:level], scanner[:offset], scanner[:type]
+    return nil if type.nil?
+
+    attributes = {}
+    while scanner.scan(/    <\h+>   DW_AT_(?<key>[^ ]+) *:( \([^\)]+\):)? (?<value>[^\n]+)\n/)
+      key, value = scanner[:key], scanner[:value]
+      attributes[key.to_sym] = value
+    end
+
+    build_die(type, level: Integer(level), offset: offset.to_i(16), attributes: attributes)
+  end
+
+  # @param [String] type
+  # @param [Integer] level
+  # @param [Integer] offset
+  # @param [Hash{ Symbol => String }] attributes
+  # @return [Dwarftree::DIE::*]
+  def build_die(type, level:, offset:, attributes:)
+    const = type.split('_').map { |s| s.sub(/\A\w/, &:upcase) }.join
+    klass = Dwarftree::DIE.const_get(const, false)
+    begin
+      die = klass.new(**attributes)
+    rescue ArgumentError
+      $stderr.puts "Caught ArgumentError on Dwarftree::DIE::#{const}.new"
+      raise
+    end
+    die.type  = type
+    die.level = level
+    @offset_die[offset] = die
+  end
+
+  def resolve_references(die)
+    if die.respond_to?(:ranges) && die[:ranges]
+      die.ranges = @offset_ranges.fetch(die[:ranges].to_i(16))
+    end
+    if die.respond_to?(:abstract_origin) && die[:abstract_origin]
+      offset = die[:abstract_origin].match(/\A<0x(?<offset>\h+)>\z/)[:offset]
+      die.abstract_origin = @offset_die.fetch(offset.to_i(16))
+    end
+  end
+
+  # @param [Array<Dwarftree::DIE::*>] nodes
+  def build_tree(nodes)
+    stack = [nodes.first]
+    nodes.drop(1).each do |node|
+      while stack.last.level + 1 > node.level
+        stack.pop
+      end
+      if stack.last.level + 1 != node.level
+        raise ParserError.new("unexpected node level #{node.level} against stack #{stack.last.level}")
+      end
+      stack.last.children << node
+      stack.push(node)
+    end
+    stack.first
+  end
+end

data/lib/dwarftree/debug_ranges_parser.rb

@@ -0,0 +1,24 @@
+class Dwarftree::DebugRangesParser
+  CommandError = Class.new(StandardError)
+
+  # @param [String] object
+  def self.parse(object)
+    cmd = ['objdump', '--dwarf=Ranges', object]
+    debug_ranges = IO.popen(cmd, &:read)
+    unless $?.success?
+      raise CommandError.new("Failed to run: #{cmd.join(' ')}")
+    end
+    new.parse(debug_ranges)
+  end
+
+  # @param [String] debug_ranges
+  # @return [Hash{ Integer => Array<Range<Integer>> }]
+  def parse(debug_ranges)
+    offset_ranges = Hash.new { |h, k| h[k] = [] }
+    debug_ranges.scan(/^    \h{8} \h{16} \h{16} $/) do |line|
+      offset, range_beg, range_end = line.strip.split(' ')
+      offset_ranges[offset.to_i(16)] << (range_beg.to_i(16)..range_end.to_i(16))
+    end
+    offset_ranges
+  end
+end

data/lib/dwarftree/die/array_type.rb

@@ -0,0 +1,4 @@
+Dwarftree::DIE::ArrayType = Dwarftree::DIE.new(
+  :type,
+  :sibling,
+)

data/lib/dwarftree/die/base_type.rb

@@ -0,0 +1,5 @@
+Dwarftree::DIE::BaseType = Dwarftree::DIE.new(
+  :byte_size,
+  :encoding,
+  :name,
+)

data/lib/dwarftree/die/compile_unit.rb

@@ -0,0 +1,17 @@
+Dwarftree::DIE::CompileUnit = Dwarftree::DIE.new(
+  :producer,
+  :language,
+  :name,
+  :comp_dir,
+  :ranges,
+  :low_pc,
+  :high_pc,
+  :stmt_list,
+  :GNU_macros,
+) do
+  self.attributes = [:name]
+
+  def name
+    File.expand_path(self[:name], comp_dir)
+  end
+end

data/lib/dwarftree/die/const_type.rb

@@ -0,0 +1,3 @@
+Dwarftree::DIE::ConstType = Dwarftree::DIE.new(
+  :type,
+)

data/lib/dwarftree/die/dwarf_procedure.rb

@@ -0,0 +1,5 @@
+Dwarftree::DIE::DwarfProcedure = Dwarftree::DIE.new(
+  :location,
+) do
+  self.attributes = []
+end

data/lib/dwarftree/die/enumeration_type.rb

@@ -0,0 +1,9 @@
+Dwarftree::DIE::EnumerationType = Dwarftree::DIE.new(
+  :name,
+  :encoding,
+  :byte_size,
+  :type,
+  :decl_file,
+  :decl_line,
+  :sibling,
+)

data/lib/dwarftree/die/enumerator.rb

@@ -0,0 +1,4 @@
+Dwarftree::DIE::Enumerator = Dwarftree::DIE.new(
+  :name,
+  :const_value,
+)

data/lib/dwarftree/die/formal_parameter.rb

@@ -0,0 +1,13 @@
+Dwarftree::DIE::FormalParameter = Dwarftree::DIE.new(
+  :name,
+  :decl_file,
+  :decl_line,
+  :type,
+  :location,
+  :abstract_origin,
+  :const_value,
+) do
+  def abstract_origin
+    self[:abstract_origin]&.name
+  end
+end

data/lib/dwarftree/die/gnu_call_site.rb

@@ -0,0 +1,12 @@
+Dwarftree::DIE::GNUCallSite = Dwarftree::DIE.new(
+  :low_pc,
+  :ranges,
+  :sibling,
+  :abstract_origin,
+  :GNU_tail_call,
+  :GNU_call_site_target,
+) do
+  def abstract_origin
+    self[:abstract_origin]&.name
+  end
+end

data/lib/dwarftree/die/gnu_call_site_parameter.rb

@@ -0,0 +1,7 @@
+Dwarftree::DIE::GNUCallSiteParameter = Dwarftree::DIE.new(
+  :location,
+  :GNU_call_site_value,
+  :abstract_origin,
+) do
+  self.attributes = [:location]
+end

data/lib/dwarftree/die/inlined_subroutine.rb

@@ -0,0 +1,16 @@
+Dwarftree::DIE::InlinedSubroutine = Dwarftree::DIE.new(
+  :abstract_origin,
+  :entry_pc,
+  :ranges,
+  :call_file,
+  :call_line,
+  :sibling,
+  :low_pc,
+  :high_pc,
+) do
+  self.attributes = [:abstract_origin]
+
+  def abstract_origin
+    self[:abstract_origin].name
+  end
+end

data/lib/dwarftree/die/label.rb

@@ -0,0 +1,11 @@
+Dwarftree::DIE::Label = Dwarftree::DIE.new(
+  :name,
+  :decl_file,
+  :decl_line,
+  :low_pc,
+  :abstract_origin,
+) do
+  def abstract_origin
+    self[:abstract_origin]&.name
+  end
+end

data/lib/dwarftree/die/lexical_block.rb

@@ -0,0 +1,11 @@
+Dwarftree::DIE::LexicalBlock = Dwarftree::DIE.new(
+  :low_pc,
+  :high_pc,
+  :ranges,
+  :sibling,
+  :abstract_origin,
+) do
+  def abstract_origin
+    self[:abstract_origin]&.type
+  end
+end

data/lib/dwarftree/die/member.rb

@@ -0,0 +1,10 @@
+Dwarftree::DIE::Member = Dwarftree::DIE.new(
+  :name,
+  :decl_file,
+  :decl_line,
+  :type,
+  :byte_size,
+  :bit_size,
+  :bit_offset,
+  :data_member_location,
+)

data/lib/dwarftree/die/pointer_type.rb

@@ -0,0 +1,5 @@
+Dwarftree::DIE::PointerType = Dwarftree::DIE.new(
+  :pointer_type,
+  :byte_size,
+  :type,
+)

data/lib/dwarftree/die/restrict_type.rb

@@ -0,0 +1,3 @@
+Dwarftree::DIE::RestrictType = Dwarftree::DIE.new(
+  :type,
+)

data/lib/dwarftree/die/structure_type.rb

@@ -0,0 +1,8 @@
+Dwarftree::DIE::StructureType = Dwarftree::DIE.new(
+  :name,
+  :byte_size,
+  :decl_file,
+  :decl_line,
+  :sibling,
+  :declaration,
+)

data/lib/dwarftree/die/subprogram.rb

@@ -0,0 +1,22 @@
+Dwarftree::DIE::Subprogram = Dwarftree::DIE.new(
+  :external,
+  :name,
+  :decl_file,
+  :decl_line,
+  :prototyped,
+  :type,
+  :low_pc,
+  :high_pc,
+  :frame_base,
+  :declaration,
+  :inline,
+  :sibling,
+  :artificial,
+  :noreturn,
+  :GNU_all_call_sites,
+  :linkage_name,
+  :abstract_origin,
+  :GNU_all_tail_call_sites,
+) do
+  self.attributes = [:name, :inline]
+end

data/lib/dwarftree/die/subrange_type.rb

@@ -0,0 +1,4 @@
+Dwarftree::DIE::SubrangeType = Dwarftree::DIE.new(
+  :type,
+  :upper_bound,
+)

data/lib/dwarftree/die/subroutine_type.rb

@@ -0,0 +1,5 @@
+Dwarftree::DIE::SubroutineType = Dwarftree::DIE.new(
+  :prototyped,
+  :type,
+  :sibling,
+)

data/lib/dwarftree/die/typedef.rb

@@ -0,0 +1,6 @@
+Dwarftree::DIE::Typedef = Dwarftree::DIE.new(
+  :name,
+  :decl_file,
+  :decl_line,
+  :type,
+)

data/lib/dwarftree/die/union_type.rb

@@ -0,0 +1,7 @@
+Dwarftree::DIE::UnionType = Dwarftree::DIE.new(
+  :byte_size,
+  :decl_file,
+  :decl_line,
+  :sibling,
+  :name,
+)

data/lib/dwarftree/die/unspecified_parameters.rb

@@ -0,0 +1 @@
+Dwarftree::DIE::UnspecifiedParameters = Dwarftree::DIE.new

data/lib/dwarftree/die/variable.rb

@@ -0,0 +1,17 @@
+Dwarftree::DIE::Variable = Dwarftree::DIE.new(
+  :name,
+  :decl_file,
+  :decl_line,
+  :type,
+  :external,
+  :declaration,
+  :location,
+  :const_value,
+  :artificial,
+  :abstract_origin,
+  :specification,
+) do
+  def abstract_origin
+    self[:abstract_origin]&.name
+  end
+end

data/lib/dwarftree/die/volatile_type.rb

@@ -0,0 +1,3 @@
+Dwarftree::DIE::VolatileType = Dwarftree::DIE.new(
+  :type,
+)

data/lib/dwarftree/die.rb

@@ -0,0 +1,71 @@
+# Debugging Information Entry
+module Dwarftree::DIE
+  using Module.new {
+    refine Struct.singleton_class do
+      def new(*args, **_opts, &block)
+        if args.empty?
+          # Pseudo Struct for no-member DIE
+          Class.new do
+            def self.members
+              []
+            end
+
+            if block
+              class_exec(&block)
+            end
+          end
+        else
+          super
+        end
+      end
+    end
+  }
+
+  def self.new(*args, &block)
+    Struct.new(*args, keyword_init: true) do
+      class << self
+        attr_accessor :attributes
+      end
+      self.attributes = members
+
+      # Not in members to avoid a conflict with DIE attributes
+      attr_accessor :type, :level, :children
+
+      def initialize(**)
+        super
+        self.children = []
+      end
+
+      if block
+        class_exec(&block)
+      end
+      freeze
+    end
+  end
+
+  require 'dwarftree/die/array_type'
+  require 'dwarftree/die/base_type'
+  require 'dwarftree/die/compile_unit'
+  require 'dwarftree/die/const_type'
+  require 'dwarftree/die/dwarf_procedure'
+  require 'dwarftree/die/enumeration_type'
+  require 'dwarftree/die/enumerator'
+  require 'dwarftree/die/formal_parameter'
+  require 'dwarftree/die/gnu_call_site'
+  require 'dwarftree/die/gnu_call_site_parameter'
+  require 'dwarftree/die/inlined_subroutine'
+  require 'dwarftree/die/label'
+  require 'dwarftree/die/lexical_block'
+  require 'dwarftree/die/member'
+  require 'dwarftree/die/pointer_type'
+  require 'dwarftree/die/restrict_type'
+  require 'dwarftree/die/structure_type'
+  require 'dwarftree/die/subprogram'
+  require 'dwarftree/die/subrange_type'
+  require 'dwarftree/die/subroutine_type'
+  require 'dwarftree/die/typedef'
+  require 'dwarftree/die/union_type'
+  require 'dwarftree/die/unspecified_parameters'
+  require 'dwarftree/die/variable'
+  require 'dwarftree/die/volatile_type'
+end

data/lib/dwarftree/tree_filter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+class Dwarftree::TreeFilter
+  using Module.new {
+    refine Array do
+      def flat_map!(&block)
+        replace(flat_map(&block))
+      end
+    end
+  }
+
+  # @param [Set<String>] subprograms
+  # @param [Set<String>] dies
+  def initialize(subprograms:, dies:)
+    @subprograms = subprograms
+    @dies = dies
+  end
+
+  # @param [Array<Dwarftree::DIE::*>] nodes
+  def filter!(nodes, filter_subprogram: @subprograms.empty?)
+    unless @subprograms.empty?
+      filter_subprograms!(nodes)
+    end
+    unless @dies.empty?
+      filter_dies!(nodes)
+    end
+  end
+
+  private
+
+  # @param [Array<Dwarftree::DIE::*>] nodes - Modified to Array<Dwarftree::DIE::Subprogram> after this call
+  def filter_subprograms!(nodes)
+    nodes.flat_map! do |node|
+      if matching_subprogram?(node)
+        node
+      else
+        filter_subprograms!(node.children)
+        node.children
+      end
+    end
+  end
+
+  def filter_dies!(nodes)
+    nodes.flat_map! do |node|
+      filter_dies!(node.children)
+
+      # Exactly-matched subprogram should not be filtered out
+      if matching_subprogram?(node) || @dies.include?(node.type)
+        node
+      else
+        node.children
+      end
+    end
+  end
+
+  def matching_subprogram?(node)
+    node.type == 'subprogram' && @subprograms.include?(node.name)
+  end
+end

data/lib/dwarftree/tree_visualizer.rb

@@ -0,0 +1,69 @@
+class Dwarftree::TreeVisualizer
+  KiB = 1024
+  MiB = KiB * 1024
+
+  # @param [TrueClass,FalseClass] show_size
+  # @param [TrueClass,FalseClass] sort_size
+  def initialize(show_size:, sort_size:)
+    @show_size = show_size
+    @sort_size = sort_size
+  end
+
+  # @param [Array<Dwarftree::DIE::*>] nodes
+  def visualize(nodes)
+    sort(nodes).each do |node|
+      visualize_node(node)
+    end
+  end
+
+  private
+
+  # @param [Dwarftree::DIE::*] node
+  def visualize_node(node, depth: 0)
+    size = node_code_size(node)
+    print "#{'  ' * depth}#{node.type}"
+    puts "#{(" size=#{human_size(size)}" if @show_size && size)} #{node_attributes(node)}"
+
+    sort(node.children).each do |child|
+      visualize_node(child, depth: depth + 1)
+    end
+  end
+
+  def node_attributes(node)
+    attrs = node.class.attributes.map do |attr|
+      if value = node.public_send(attr)
+        "#{attr}: #{value}"
+      end
+    end
+    attrs.compact!
+
+    return '' if attrs.empty?
+    "(#{attrs.join(', ')})"
+  end
+
+  def node_code_size(node)
+    if node.respond_to?(:ranges) && node.ranges
+      node.ranges.map { |range| range.end - range.begin }.sum
+    elsif node.respond_to?(:high_pc) && node.high_pc
+      node.high_pc.to_i(16) # surprisingly low_pc is not needed to know code size
+    end
+  end
+
+  def human_size(size)
+    if size > MiB
+      "%.1fM" % (size.to_f / MiB)
+    elsif size > KiB
+      "%.1fK" % (size.to_f / KiB)
+    else
+      size
+    end
+  end
+
+  def sort(nodes)
+    if @sort_size
+      nodes.sort_by { |node| -(node_code_size(node) || 0) }
+    else
+      nodes
+    end
+  end
+end

data/lib/dwarftree/version.rb

@@ -0,0 +1,3 @@
+module Dwarftree
+  VERSION = '0.1.0'
+end

data/lib/dwarftree.rb

@@ -0,0 +1,24 @@
+module Dwarftree
+  require 'dwarftree/debug_info_parser'
+  require 'dwarftree/tree_filter'
+  require 'dwarftree/tree_visualizer'
+
+  # @param [String] object
+  # @param [Array<String>] dies
+  # @param [Array<String>] subprograms
+  # @param [TrueClass,FalseClass] show_size
+  # @param [TrueClass,FalseClass] sort_size
+  def self.run(object, dies:, subprograms:, show_size:, sort_size:)
+    begin
+      nodes = DebugInfoParser.parse(object)
+    rescue DebugInfoParser::CommandError => e
+      abort "ERROR: #{e.message}"
+    end
+    if nodes.empty?
+      abort "Debug info was not found in #{object.dump}"
+    end
+
+    Dwarftree::TreeFilter.new(dies: dies, subprograms: subprograms).filter!(nodes)
+    Dwarftree::TreeVisualizer.new(show_size: show_size, sort_size: sort_size).visualize(nodes)
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: dwarftree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Takashi Kokubun
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-05-11 00:00:00.000000000 Z
+dependencies: []
+description: A wrapper of `objdump --dwarf=info` to visualize a structure of inlined
+  subroutines
+email:
+- takashikkbn@gmail.com
+executables:
+- dwarftree
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dwarftree.gemspec
+- exe/dwarftree
+- lib/dwarftree.rb
+- lib/dwarftree/debug_info_parser.rb
+- lib/dwarftree/debug_ranges_parser.rb
+- lib/dwarftree/die.rb
+- lib/dwarftree/die/array_type.rb
+- lib/dwarftree/die/base_type.rb
+- lib/dwarftree/die/compile_unit.rb
+- lib/dwarftree/die/const_type.rb
+- lib/dwarftree/die/dwarf_procedure.rb
+- lib/dwarftree/die/enumeration_type.rb
+- lib/dwarftree/die/enumerator.rb
+- lib/dwarftree/die/formal_parameter.rb
+- lib/dwarftree/die/gnu_call_site.rb
+- lib/dwarftree/die/gnu_call_site_parameter.rb
+- lib/dwarftree/die/inlined_subroutine.rb
+- lib/dwarftree/die/label.rb
+- lib/dwarftree/die/lexical_block.rb
+- lib/dwarftree/die/member.rb
+- lib/dwarftree/die/pointer_type.rb
+- lib/dwarftree/die/restrict_type.rb
+- lib/dwarftree/die/structure_type.rb
+- lib/dwarftree/die/subprogram.rb
+- lib/dwarftree/die/subrange_type.rb
+- lib/dwarftree/die/subroutine_type.rb
+- lib/dwarftree/die/typedef.rb
+- lib/dwarftree/die/union_type.rb
+- lib/dwarftree/die/unspecified_parameters.rb
+- lib/dwarftree/die/variable.rb
+- lib/dwarftree/die/volatile_type.rb
+- lib/dwarftree/tree_filter.rb
+- lib/dwarftree/tree_visualizer.rb
+- lib/dwarftree/version.rb
+homepage: https://github.com/k0kubun/dwarftree
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.0.pre1
+signing_key: 
+specification_version: 4
+summary: A wrapper of `objdump --dwarf=info` to visualize a structure of inlined subroutines
+test_files: []