metasm 1.0.3 → 1.0.4

data/metasm/gui/dasm_decomp.rb

@@ -6,7 +6,7 @@
 module Metasm
 module Gui
 class CdecompListingWidget < DrawableWidget
-	attr_accessor :dasm, :curaddr, :tabwidth
+	attr_accessor :dasm, :curfuncaddr, :tabwidth
 
 	def initialize_widget(dasm, parent_widget)
 		@dasm = dasm
@@ -16,7 +16,8 @@ class CdecompListingWidget < DrawableWidget
 		@cwidth = @cheight = 1	# widget size in chars
 		@line_text = []
 		@line_text_col = []	# each line is [[:col, 'text'], [:col, 'text']]
-		@curaddr = nil
+		@line_addr = []
+		@curfuncaddr = nil
 		@tabwidth = 8
 
 		@default_color_association = ColorTheme.merge :keyword => :blue, :localvar => :darkred,
@@ -24,7 +25,7 @@ class CdecompListingWidget < DrawableWidget
 	end
 
 	def curfunc
-		@dasm.c_parser and (@dasm.c_parser.toplevel.symbol[@curaddr] or @dasm.c_parser.toplevel.struct[@curaddr])
+		@dasm.c_parser and (@dasm.c_parser.toplevel.symbol[@curfuncaddr] or @dasm.c_parser.toplevel.struct[@curfuncaddr])
 	end
 
 	def click(x, y)
@@ -59,7 +60,6 @@ class CdecompListingWidget < DrawableWidget
 			if @caret_y < @line_text.length - 1
 				@view_y += 4
 				@caret_y += 4
-				redraw
 			end
 		end
 		redraw
@@ -148,92 +148,127 @@ class CdecompListingWidget < DrawableWidget
 			@caret_x = @line_text[@caret_y].to_s.length
 			update_caret
 		when :pgup
-			@caret_y -= @cheight/2
-			@caret_y = 0 if @caret_y < 0
-			update_caret
+			if @caret_y > 0
+				@view_y -= @cheight/2
+				@caret_y -= @cheight/2
+				@caret_y = 0 if @caret_y < 0
+				redraw
+			end
 		when :pgdown
-			@caret_y += @cheight/2
-			@caret_y = @line_text.length if @caret_y > @line_text.length
-			update_caret
-		when ?n	# rename local/global variable
-			f = curfunc.initializer if curfunc and curfunc.initializer.kind_of? C::Block
-			n = @hl_word
-			if (f and f.symbol[n]) or @dasm.c_parser.toplevel.symbol[n]
-				@parent_widget.inputbox("new name for #{n}", :text => n) { |v|
-					if v !~ /^[a-z_$][a-z_0-9$]*$/i
-						@parent_widget.messagebox("invalid name #{v.inspect} !")
-						next
-					end
-					if f and f.symbol[n]
-						# TODO add/update comment to the asm instrs
-						s = f.symbol[v] = f.symbol.delete(n)
-						s.name = v
-						f.decompdata[:stackoff_name][s.stackoff] = v if s.stackoff
-					elsif @dasm.c_parser.toplevel.symbol[n]
-						@dasm.rename_label(n, v)
-						@curaddr = v if @curaddr == n
-					end
-					gui_update
-				}
+			if @caret_y < @line_text.length
+				@view_y += @cheight/2
+				@caret_y += @cheight/2
+				@caret_y = @line_text.length if @caret_y > @line_text.length
+				redraw
 			end
+		when ?n	# rename local/global variable
+			prompt_rename
 		when ?r # redecompile
-			@parent_widget.decompile(@curaddr)
-		when ?t	# change variable type (you'll want to redecompile after that)
-			f = curfunc.initializer if curfunc.kind_of? C::Variable and curfunc.initializer.kind_of? C::Block
-			n = @hl_word
-			cp = @dasm.c_parser
-			if (f and s = f.symbol[n]) or s = cp.toplevel.symbol[n] or s = cp.toplevel.symbol[@curaddr]
-				s_ = s.dup
-				s_.initializer = nil if s.kind_of? C::Variable	# for static var, avoid dumping the initializer in the textbox
-				s_.attributes &= C::Attributes::DECLSPECS if s_.attributes
-				@parent_widget.inputbox("new type for #{s.name}", :text => s_.dump_def(cp.toplevel)[0].join(' ')) { |t|
-					if t == ''
-						if s.type.kind_of? C::Function and s.initializer and s.initializer.decompdata
-							s.initializer.decompdata[:stackoff_type].clear
-							s.initializer.decompdata.delete :return_type
-						elsif s.kind_of? C::Variable and s.stackoff
-							f.decompdata[:stackoff_type].delete s.stackoff
-						end
-						next
+			@parent_widget.decompile(@curfuncaddr)
+		when ?t, ?y	# change variable type (you'll want to redecompile after that)
+			prompt_retype
+		when ?h
+			display_hex
+		else return false
+		end
+		true
+	end
+
+	def prompt_rename
+		f = curfunc.initializer if curfunc and curfunc.initializer.kind_of?(C::Block)
+		n = @hl_word
+		if (f and f.symbol[n]) or @dasm.c_parser.toplevel.symbol[n]
+			@parent_widget.inputbox("new name for #{n}", :text => n) { |v|
+				if v !~ /^[a-z_$][a-z_0-9$]*$/i
+					@parent_widget.messagebox("invalid name #{v.inspect} !")
+					next
+				end
+				if f and f.symbol[n]
+					# TODO add/update comment to the asm instrs
+					s = f.symbol[v] = f.symbol.delete(n)
+					s.misc ||= {}
+					uan = s.misc[:unalias_name] ||= n
+					s.name = v
+					f.decompdata[:unalias_name][uan] = v
+				elsif @dasm.c_parser.toplevel.symbol[n]
+					@dasm.rename_label(n, v)
+					@curfuncaddr = v if @curfuncaddr == n
+				end
+				gui_update
+			}
+		end
+	end
+
+	def prompt_retype
+		f = curfunc.initializer if curfunc.kind_of?(C::Variable) and curfunc.initializer.kind_of?(C::Block)
+		n = @hl_word
+		cp = @dasm.c_parser
+		if (f and s = f.symbol[n]) or s = cp.toplevel.symbol[n] or s = cp.toplevel.symbol[@curfuncaddr]
+			s_ = s.dup
+			s_.initializer = nil if s.kind_of?(C::Variable)	# for static var, avoid dumping the initializer in the textbox
+			s_.attributes &= C::Attributes::DECLSPECS if s_.attributes
+			@parent_widget.inputbox("new type for #{s.name}", :text => s_.dump_def(cp.toplevel)[0].join(' ')) { |t|
+				if t == ''
+					if s.type.kind_of?(C::Function) and s.initializer and s.initializer.decompdata
+						s.initializer.decompdata.delete(:return_type)
+					elsif f.symbol[n] and s.kind_of?(C::Variable)
+						s.misc ||= {}
+						uan = s.misc[:unalias_name] ||= s.name
+						f.decompdata[:unalias_type].delete uan
 					end
-					begin
-						cp.lexer.feed(t)
-						raise 'bad type' if not v = C::Variable.parse_type(cp, cp.toplevel, true)
-						v.parse_declarator(cp, cp.toplevel)
-						if s.type.kind_of? C::Function and s.initializer and s.initializer.decompdata
-							# updated type of a decompiled func: update stack
-							vt = v.type.untypedef
-							vt = vt.type.untypedef if vt.kind_of? C::Pointer
-							raise 'function forever !' if not vt.kind_of? C::Function
-							# TODO _declspec
-							ao = 1
-							vt.args.to_a.each { |a|
-								next if a.has_attribute_var('register')
-								ao = (ao + [cp.sizeof(a), cp.typesize[:ptr]].max - 1) / cp.typesize[:ptr] * cp.typesize[:ptr]
-								s.initializer.decompdata[:stackoff_name][ao] = a.name if a.name
-								s.initializer.decompdata[:stackoff_type][ao] = a.type
-								ao += cp.sizeof(a)
-							}
-							s.initializer.decompdata[:return_type] = vt.type
-							s.type = v.type
-						else
-							f.decompdata[:stackoff_type][s.stackoff] = v.type if f and s.kind_of? C::Variable and s.stackoff
-							s.type = v.type
-						end
-						gui_update
-					rescue Object
-						@parent_widget.messagebox([$!.message, $!.backtrace].join("\n"), "error")
+					next
+				end
+				begin
+					cp.lexer.feed(t)
+					raise 'bad type' if not v = C::Variable.parse_type(cp, cp.toplevel, true)
+					v.parse_declarator(cp, cp.toplevel)
+					if s.type.kind_of?(C::Function) and s.initializer and s.initializer.decompdata
+						# updated type of a decompiled func: update stack
+						vt = v.type.untypedef
+						vt = vt.type.untypedef if vt.kind_of?(C::Pointer)
+						raise 'function forever !' if not vt.kind_of?(C::Function)
+						# TODO _declspec
+						vt.args.to_a.each_with_index { |a, idx|
+							oa = curfunc.type.args.to_a[idx]
+							oa.misc ||= {}
+							a.misc ||= {}
+							uan = a.misc[:unalias_name] = oa.misc[:unalias_name] ||= oa.name
+							s.initializer.decompdata[:unalias_name][uan] = a.name if a.name
+							s.initializer.decompdata[:unalias_type][uan] = a.type
+						}
+						s.initializer.decompdata[:return_type] = vt.type
+						s.type = v.type
+					elsif f and s.kind_of?(C::Variable) and f.symbol[s.name]
+						s.misc ||= {}
+						uan = s.misc[:unalias_name] ||= s.name
+						f.decompdata[:unalias_type][uan] = v.type
+						s.type = v.type
 					end
-					cp.readtok until cp.eos?
-				}
+					gui_update
+				rescue Object
+					@parent_widget.messagebox([$!.message, $!.backtrace].join("\n"), "error")
+				end
+				cp.readtok until cp.eos?
+			}
+		end
+	end
+
+	# change the display of an integer from hex to decimal
+	def display_hex
+		ce = curobj
+		if ce.kind_of?(C::CExpression) and not ce.op and ce.rexpr.kind_of?(::Integer)
+			ce.misc ||= {}
+			if ce.misc[:custom_display] =~ /^0x/
+				ce.misc[:custom_display] = ce.rexpr.to_s
+			else
+				ce.misc[:custom_display] = '0x%X' % ce.rexpr
 			end
-		else return false
+			gui_update
 		end
-		true
 	end
 
 	def get_cursor_pos
-		[@curaddr, @caret_x, @caret_y, @view_y]
+		[@curfuncaddr, @caret_x, @caret_y, @view_y]
 	end
 
 	def set_cursor_pos(p)
@@ -258,7 +293,7 @@ class CdecompListingWidget < DrawableWidget
 	# returns true on success (address exists & decompiled)
 	def focus_addr(addr)
 		if @dasm.c_parser and (@dasm.c_parser.toplevel.symbol[addr] or @dasm.c_parser.toplevel.struct[addr].kind_of?(C::Union))
-			@curaddr = addr
+			@curfuncaddr = addr
 			@caret_x = @caret_y = 0
 			gui_update
 			return true
@@ -270,34 +305,75 @@ class CdecompListingWidget < DrawableWidget
 		todo = [addr]
 		done = []
 		ep = @dasm.entrypoints.to_a.inject({}) { |h, e| h.update @dasm.normalize(e) => true }
-		while addr = todo.pop
-			next if not di = @dasm.di_at(addr)
-			addr = di.block.address
-			next if done.include?(addr) or not @dasm.di_at(addr)
-			done << addr
-			break if @dasm.function[addr] or ep[addr]
+		while laddr = todo.pop
+			next if not di = @dasm.di_at(laddr)
+			laddr = di.block.address
+			next if done.include?(laddr) or not @dasm.di_at(laddr)
+			done << laddr
+			break if @dasm.function[laddr] or ep[laddr]
 			empty = true
-			@dasm.decoded[addr].block.each_from_samefunc(@dasm) { |na| empty = false ; todo << na }
+			@dasm.decoded[laddr].block.each_from_samefunc(@dasm) { |na| empty = false ; todo << na }
 			break if empty
 		end
-		@dasm.auto_label_at(addr, 'loc') if @dasm.get_section_at(addr) and not @dasm.get_label_at(addr)
-		return if not l = @dasm.get_label_at(addr)
-		@curaddr = l
+		@dasm.auto_label_at(laddr, 'loc') if @dasm.get_section_at(laddr) and not @dasm.get_label_at(laddr)
+		return if not l = @dasm.get_label_at(laddr)
+		@curfuncaddr = l
 		@caret_x = @caret_y = 0
+		@want_addr = addr
 		gui_update
 		true
 	end
 
 	# returns the address of the data under the cursor
 	def current_address
-		@curaddr
+		if @line_c[@caret_y]
+			lc = {}
+			@line_c[@caret_y].each { |k, v|
+				lc[k] = v if v.misc and v.misc[:di_addr]
+			}
+			o = lc.keys.sort.reverse.find  { |oo| oo < @caret_x } || lc.keys.min
+		end
+		o ? lc[o].misc[:di_addr] : @curfuncaddr
+	end
+
+	# return the C object under the cursor
+	def curobj
+		if lc = @line_c[@caret_y]
+			o = lc.keys.sort.reverse.find  { |oo| oo < @caret_x } || lc.keys.min
+		end
+		o ? lc[o] : curfunc
 	end
 
+
 	def update_line_text
-		@line_text = curfunc.dump_def(@dasm.c_parser.toplevel)[0].map { |l| l.gsub("\t", ' '*@tabwidth) }
+		text = curfunc.dump_def(@dasm.c_parser.toplevel)[0]
+		@line_text = text.map { |l| l.gsub("\t", ' '*@tabwidth) }
+		# y => { x => C }
+		@line_c = text.map { |l|
+			h = {}
+			l.c_at_offset.each { |o, c|
+				oo = l[0, o].gsub("\t", ' '*@tabwidth).length
+				h[oo] = c
+			}
+			h
+		}
+
+		@want_addr ||= nil
+		# define @caret_y to match @want_addr from focus_addr()
+		@line_c.each_with_index { |lc, y|
+			next if not @want_addr
+			lc.each { |o, c|
+				if @want_addr and c.misc and c.misc[:di_addr]
+					@caret_x, @caret_y = o, y+1 if @want_addr > c.misc[:di_addr]
+					@want_addr = nil if @want_addr <= c.misc[:di_addr]
+				end
+			}
+		}
+		@want_addr = nil
+
 		@line_text_col = []
 
-		if f = curfunc and f.kind_of? C::Variable and f.initializer.kind_of? C::Block
+		if f = curfunc and f.kind_of?(C::Variable) and f.initializer.kind_of?(C::Block)
 			keyword_re = /\b(#{C::Keyword.keys.join('|')})\b/
 			intrinsic_re = /\b(intrinsic_\w+)\b/
 			lv = f.initializer.symbol.keys
@@ -342,7 +418,7 @@ class CdecompListingWidget < DrawableWidget
 			@line_text_col = [[[:text, 'please wait']]]
 			redraw
 			@decompiling = true
-			@dasm.decompile_func(@curaddr)
+			protect { @dasm.decompile_func(@curfuncaddr) }
 			@decompiling = false
 		end
 		if curfunc

data/metasm/gui/dasm_graph.rb

@@ -78,6 +78,27 @@ class Graph
 			ar << head
 		end
 
+		# recenter boxes (a -> [b, c, d] => center a around b+c+d)
+		(ar.length - 1).times { |i|
+			g = ar[i]
+			gn = ar[i+1]
+			withchld = g.content.find_all { |b| not b.to.empty? }
+			wc = withchld[0]
+			if withchld.length == 1 and wc.to.length >= 1 and wc.to & gn.content == wc.to
+				tox = wc.to.map { |b| b.x }.min
+				toxmax = wc.to.map { |b| b.x + b.w }.max
+				# dx1: center wc center around (wc.to.xmin + wc.to.xmax)/2
+				dx1 = tox + (toxmax-tox)/2 - (wc.x + wc.w/2)
+				# dx2: center wc center around the mean of the centers of wc.to
+				dx2 = wc.to.map { |b| b.x + b.w/2 }.inject(0) { |a, b| a+b } / wc.to.length - (wc.x + wc.w/2)
+				dx = (dx1 + dx2) / 2
+				ar.length.times { |j|
+					ar[j].w += dx
+					ar[j].content.each { |b| b.x += (j<=i ? dx/2 : -dx/2) }
+				}
+			end
+		}
+
 		# move boxes inside this group
 		maxw = ar.map { |g| g.w }.max
 		fullh = ar.inject(0) { |h, g| h + g.h }
@@ -158,10 +179,48 @@ class Graph
 			g.content.each { |b| b.x += dx ; b.y += dy }
 			curx += g.w
 		}
+
+		# shrink horizontally if possible
+		(ar.length - 1).times { |i1|
+			g1 = ar[i1]
+			g2 = ar[i1+1]
+			next if g1.content.empty? or g2.content.empty?
+			# only work with full groups, dont try to interleave gaps
+			# see if all of one's boxes can be slightly moved inside the other
+			g1ymin = g1.content.map { |b| b.y - 9 }.min
+			g1ymax = g1.content.map { |b| b.y + b.h + 9 }.max
+			g2ymin = g2.content.map { |b| b.y - 9 }.min
+			g2ymax = g2.content.map { |b| b.y + b.h + 9 }.max
+			g1_matchg2 = g1.content.find_all { |b| b.y + b.h > g2ymin and b.y < g2ymax }
+			g2_matchg1 = g2.content.find_all { |b| b.y + b.h > g1ymin and b.y < g1ymax }
+			if g1_matchg2.length > 0 and g2_matchg1.length > 0
+				g1_up = g1.content.find_all { |b| b.y + b.h < g2ymin }
+				g1_down = g1.content.find_all { |b| b.y > g2ymax }
+				g2_up = g2.content.find_all { |b| b.y + b.h < g1ymin }
+				g2_down = g2.content.find_all { |b| b.y > g1ymax }
+				# avoid moving into an arrow
+				xmin = g1_matchg2.map { |b| b.x + b.w + 8 }.max
+				xmax = g2_matchg1.map { |b| b.x - 8 }.min
+				if g1_up.length > 0 and g1_down.length > 0
+					xmin = [xmin, g1_up.map { |b| b.x + b.w/2 + 8 }.max, g1_down.map { |b| b.x + b.w/2 + 8 }.max].max
+				end
+				if g2_up.length > 0 and g2_down.length > 0
+					xmax = [xmax, g2_up.map { |b| b.x + b.w/2 + 8 }.min, g2_down.map { |b| b.x + b.w/2 + 8 }.min].min
+				end
+				dx = xmax - xmin
+				if dx > 0
+					ar.length.times { |i2|
+						ar[i2].content.each { |b| b.x += (i1 >= i2 ? dx/2 : -dx/2) }
+					}
+				end
+			end
+		}
+
 		# add a 'margin-top' proportionnal to the ar width
 		# this gap should be relative to the real boxes and not possible previous gaps when
 		# merging lines (eg long line + many if patterns -> dont duplicate gaps)
 		boxen = ar.map { |g| g.content }.flatten
+		fullw = boxen.map { |g| g.x + g.w + 8 }.max - boxen.map { |g| g.x - 8 }.min
 		realh = boxen.map { |g| g.y + g.h }.max - boxen.map { |g| g.y }.min
 		if maxh < realh + fullw/4
 			maxh = realh + fullw/4
@@ -640,8 +699,8 @@ class Graph
 		# no self references
 		# a box is in one and only one group in 'groups'
 		@groups.each { |g|
-			g.to   = g.content.first.to.map   { |t| h[t] if t != g }.compact
-			g.from = g.content.first.from.map { |f| h[f] if f != g }.compact
+			g.to   = g.content.first.to.map   { |t| h[t] if h[t] != g }.compact
+			g.from = g.content.first.from.map { |f| h[f] if h[f] != g }.compact
 		}
 
 		# order boxes

data/metasm/gui/dasm_hex.rb

@@ -27,7 +27,7 @@ class HexWidget < DrawableWidget
 		@oldcaret_x_data = 42
 		@focus_zone = @oldfocus_zone = :hex
 		@addr_min = @dasm.sections.keys.grep(Integer).min rescue nil
-		@addr_max = @dasm.sections.map { |s, e| s + e.length }.max rescue nil
+		@addr_max = @dasm.sections.select { |s, _| s.kind_of?(Integer) }.map { |s, e| s + e.length }.max rescue nil
 		@view_addr = @dasm.prog_binding['entrypoint'] || @addr_min || 0
 		@show_address = @show_data = @show_ascii = true
 		@data_size = 1
@@ -538,7 +538,7 @@ class HexWidget < DrawableWidget
 
 	def gui_update
 		@addr_min = @dasm.sections.keys.grep(Integer).min rescue nil
-		@addr_max = @dasm.sections.map { |s, e| s + e.length }.max rescue nil
+		@addr_max = @dasm.sections.select { |s, _| s.kind_of?(Integer) }.map { |s, e| s + e.length }.max rescue nil
 		@raw_data_cache.clear
 		redraw
 	end

data/metasm/gui/dasm_main.rb

@@ -60,6 +60,10 @@ class DisasmWidget < ContainerChoiceWidget
 		addview :cstruct,   CStructWidget.new(@dasm, self)
 
 		view(:listing).grab_focus
+
+		if ENV['METASM_DASM_PLUGINS']
+			ENV['METASM_DASM_PLUGINS'].split(',').each { |p| @dasm.load_plugin p }
+		end
 	end
 
 	attr_reader :dasm
@@ -110,7 +114,7 @@ class DisasmWidget < ContainerChoiceWidget
 
 	# returns the object under the cursor in current view (@dasm.decoded[curaddr])
 	def curobj
-		@dasm.decoded[curaddr]
+		curview.respond_to?(:curobj) ? curview.curobj : @dasm.decoded[curaddr]
 	end
 
 	# returns the address of the label under the cursor or the address of the line of the cursor
@@ -246,7 +250,8 @@ class DisasmWidget < ContainerChoiceWidget
 	# the callback is put only for the duration of the listwindow, and is not reentrant.
 	def list_bghilight(title, list, a={}, &b)
 		prev_colorcb = bg_color_callback
-		hash = list[1..-1].inject({}) { |h, l| h.update Expression[l[0] || :unknown].reduce => true }
+		addr_idx = a.delete(:bghilight_index) || 0
+		hash = list[1..-1].inject({}) { |h, l| h.update Expression[l[addr_idx] || :unknown].reduce => true }
 		@bg_color_callback = lambda { |addr| hash[addr] ? '0f0' : prev_colorcb ? prev_colorcb[addr] : nil }
 		redraw
 		popupend = lambda { @bg_color_callback = prev_colorcb ; redraw }
@@ -287,9 +292,9 @@ class DisasmWidget < ContainerChoiceWidget
 				@dasm.function[t] ||= @dasm.function[:default] ? @dasm.function[:default].dup : DecodedFunction.new
 			}
 			di.block.add_to_subfuncret(di.next_addr)
-			@dasm.addrs_todo << [di.next_addr, addr, true]
+			@dasm.addrs_todo << { :addr => di.next_addr, :from => addr, :from_subfuncret => true }
 		elsif addr
-			@dasm.addrs_todo << [addr]
+			@entrypoints << addr
 		end
 		start_disassemble_bg
 	end
@@ -313,7 +318,7 @@ class DisasmWidget < ContainerChoiceWidget
 		session_append "decompile(#{addr.inspect})"
 		if @dasm.c_parser and var = @dasm.c_parser.toplevel.symbol[addr] and (var.type.kind_of? C::Function or @dasm.di_at(addr))
 			@dasm.decompiler.redecompile(addr)
-			view(:decompile).curaddr = nil
+			view(:decompile).curfuncaddr = nil
 		end
 		focus_addr(addr, :decompile)
 	end
@@ -419,27 +424,31 @@ class DisasmWidget < ContainerChoiceWidget
 
 			log = []
 			dasm.backtrace(expr, addr, :log => log)
-			list = [['address', 'type', 'old value', 'value']]
+			list = [['order', 'address', 'type', 'old value', 'value']]
+			order = 0
 			log.each { |t, *a|
-				list << [Expression[a[-1]], t]
+				order += 1
+				list << [('%03d' % order), Expression[a[-1]], t] rescue next
 				case t
 				when :start
 					list.last << a[0]
 				when :up
+					order -= 1
 					list.pop
 				when :di
+					list.last[-1] = "di #{@dasm.di_at(a[-1]).instruction rescue nil}"
 					list.last << a[1] << a[0]
 				when :func
 					list.last << a[1] << a[0]
 				when :found
 					list.pop
-					a[0].each { |e_| list << [nil, :found, Expression[e_]] }
+					a[0].each { |e_| list << [('%03d' % (order += 1)), nil, :found, Expression[e_]] }
 				else
 					list.last << a[0] << a[1..-1].inspect
 				end
 			}
-			list_bghilight("backtrace #{expr} from #{Expression[addr]}", list) { |i|
-				a = i[0].empty? ? i[2] : i[0]
+			list_bghilight("backtrace #{expr} from #{Expression[addr]}", list, :bghilight_index => 1) { |i|
+				a = i[1].empty? ? i[3] : i[1]
 				focus_addr(a, nil, true)
 			}
 		}
@@ -552,8 +561,11 @@ class DisasmWidget < ContainerChoiceWidget
 				[k, Expression[@dasm.normalize(vv)]] if k.downcase.include? v.downcase
 			}.compact
 			case labels.length
-			when 0; focus_addr(v)
-			when 1; focus_addr(labels[0][0])
+			when 0
+				ve = @dasm.normalize(Expression.parse(v))
+				focus_addr(v) if not focus_addr(ve, nil, true)
+			when 1
+				focus_addr(labels[0][0])
 			else
 				if labels.all? { |k, vv| vv == labels[0][1] }
 					focus_addr(labels[0][0])
@@ -660,7 +672,7 @@ class DisasmWidget < ContainerChoiceWidget
 			true
 		elsif @dasm_pause.empty?
 			@dasm_pause = @dasm.addrs_todo.dup
-			@dasm.addrs_todo.replace @dasm_pause.find_all { |a, *b| @dasm.decoded[@dasm.normalize(a)] }
+			@dasm.addrs_todo.replace @dasm_pause.find_all { |a| @dasm.decoded[@dasm.normalize(a[:addr])] }
 			@dasm_pause -= @dasm.addrs_todo
 			puts "dasm paused (#{@dasm_pause.length})"
 		else
@@ -841,6 +853,12 @@ class DisasmWidget < ContainerChoiceWidget
 		end
 	end
 
+	def spawn_emudbg
+		edbg = EmuDebugger.new(@dasm)
+		edbg.pc = curaddr
+		DbgWindow.new(edbg)
+	end
+
 	def extend_contextmenu(tg, menu, addr=nil)
 		if @parent_widget.respond_to?(:extend_contextmenu)
 			@parent_widget.extend_contextmenu(tg, menu, addr)
@@ -885,11 +903,14 @@ end
 
 class DasmWindow < Window
 	attr_accessor :dasm_widget, :menu
-	def initialize_window(title = 'metasm disassembler', dasm=nil, *ep)
+	def initialize_window(*args)
+		dasm = args.grep(Disassembler).first
+		args -= [dasm]
+		title = args.find { |a| dasm ? !dasm.get_section_at(a) : a.kind_of?(::String) } || 'metasm disassembler'
+		ep = args - [title]
 		self.title = title
 		@dasm_widget = nil
 		if dasm
-			ep = ep.first if ep.length == 1 and ep.first.kind_of? Array
 			display(dasm, ep)
 		else
 			self.widget = NoDasmWidget.new(self)
@@ -909,10 +930,11 @@ class DasmWindow < Window
 	# returns the widget
 	def display(dasm, ep=[])
 		@dasm_widget.terminate if @dasm_widget
-		ep = [ep] if not ep.kind_of? Array
+		ep = [ep] if not ep.kind_of?(Array)
+		ep0 = ep.first
 		@dasm_widget = DisasmWidget.new(dasm, ep)
 		self.widget = @dasm_widget
-		@dasm_widget.focus_addr(ep.first) if ep.first
+		@dasm_widget.focus_addr(ep0) if ep0
 		@dasm_widget
 	end
 
@@ -941,8 +963,10 @@ class DasmWindow < Window
 				ret
 			end
 		}
-		(@dasm_widget ? DasmWindow.new : self).display(exe.disassembler)
-		self.title = "#{File.basename(path)} - metasm disassembler"
+		tg_win = self
+		tg_win = DasmWindow.new if @dasm_widget
+		tg_win.display(exe.disassembler)
+		tg_win.title = "#{File.basename(path)} - metasm disassembler"
 		exe
 	end
 
@@ -1106,6 +1130,7 @@ class DasmWindow < Window
 		addsubmenu(actions, 'Undefine function & _subfuncs') { @dasm_widget.undefine_function(@dasm_widget.curview.current_address, true) }
 		addsubmenu(actions, 'Data', 'd') { @dasm_widget.toggle_data(@dasm_widget.curview.current_address) }
 		addsubmenu(actions, 'Pause dasm', 'p', :check) { |ck| !@dasm_widget.playpause_dasm }
+		addsubmenu(actions, 'Spawn EmuDb_g', 'G') { @dasm_widget.spawn_emudbg }
 		addsubmenu(actions, 'Run ruby snippet', '^r') { promptruby }
 		addsubmenu(actions, 'Run _ruby plugin') { @dasm_widget.prompt_run_ruby_plugin }
 
@@ -1127,6 +1152,7 @@ class DasmWindow < Window
 			} if @dasm_widget
 		}
 		addsubmenu(options)
+		addsubmenu(options, 'Forbid a_ll optimizations', :check) { |ck| @dasm_widget.dasm.decompiler.forbid_all_optimizations = ck }
 		addsubmenu(options, 'Forbid decompile _types', :check) { |ck| @dasm_widget.dasm.decompiler.forbid_decompile_types = ck }
 		addsubmenu(options, 'Forbid decompile _if/while', :check) { |ck| @dasm_widget.dasm.decompiler.forbid_decompile_ifwhile = ck }
 		addsubmenu(options, 'Forbid decomp _optimize', :check) { |ck| @dasm_widget.dasm.decompiler.forbid_optimize_code = ck }