metasm 1.0.1 → 1.0.2

data/metasm/cpu/python/main.rb

@@ -0,0 +1,36 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2010 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+require 'metasm/main'
+
+module Metasm
+class Python < CPU
+	def initialize(prog = nil)
+		super()
+		@program = prog
+		@endianness = (prog.respond_to?(:endianness) ? prog.endianness : :little)
+		@size = (prog.respond_to?(:size) ? prog.size : 32)
+	end
+
+	class Var
+		include Renderable
+
+		attr_accessor :i
+
+		def initialize(i); @i = i end
+
+		def ==(o)
+			o.class == self.class and o.i == i
+		end
+
+		def symbolic; "var_#{@i}".to_sym end
+
+		def render
+			["var_#@i"]
+		end
+
+	end
+end
+end

data/metasm/cpu/python/opcodes.rb

@@ -0,0 +1,180 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2010 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+require 'metasm/cpu/python/main'
+
+module Metasm
+class Python
+	CMP_OP = %w[< <= == != > >= in not_in is is_not exch]
+
+	def addop(name, bin, *args)
+		o = Opcode.new(name)
+		o.bin = bin
+
+		args.each { |a|
+			o.args << a if @valid_args[a]
+			o.props[a] = true if @valid_props[a]
+		}
+		o.args << :i16 if o.bin >= 90 and o.props.empty?	# HAVE_ARGUMENT
+
+		@opcode_list << o
+	end
+
+	def init_opcode_list
+		@opcode_list = []
+
+		@valid_args[:u8] = true
+		@valid_args[:i16] = true
+		@valid_args[:cmp] = true
+
+		addop 'STOP_CODE', 0, :stopexec
+		addop 'POP_TOP', 1
+		addop 'ROT_TWO', 2
+		addop 'ROT_THREE', 3
+		addop 'DUP_TOP', 4
+		addop 'ROT_FOUR', 5
+		addop 'NOP', 9
+
+		addop 'UNARY_POSITIVE', 10
+		addop 'UNARY_NEGATIVE', 11
+		addop 'UNARY_NOT', 12
+		addop 'UNARY_CONVERT', 13
+
+		addop 'UNARY_INVERT', 15
+
+		addop 'BINARY_POWER', 19
+
+		addop 'BINARY_MULTIPLY', 20
+		addop 'BINARY_DIVIDE', 21
+		addop 'BINARY_MODULO', 22
+		addop 'BINARY_ADD', 23
+		addop 'BINARY_SUBTRACT', 24
+		addop 'BINARY_SUBSCR', 25
+		addop 'BINARY_FLOOR_DIVIDE', 26
+		addop 'BINARY_TRUE_DIVIDE', 27
+		addop 'INPLACE_FLOOR_DIVIDE', 28
+		addop 'INPLACE_TRUE_DIVIDE', 29
+
+		addop 'SLICE', 30
+		addop 'SLICE_1', 31
+		addop 'SLICE_2', 32
+		addop 'SLICE_3', 33
+
+		addop 'STORE_SLICE', 40
+		addop 'STORE_SLICE_1', 41
+		addop 'STORE_SLICE_2', 42
+		addop 'STORE_SLICE_3', 43
+
+		addop 'DELETE_SLICE', 50
+		addop 'DELETE_SLICE_1', 51
+		addop 'DELETE_SLICE_2', 52
+		addop 'DELETE_SLICE_3', 53
+
+		addop 'STORE_MAP', 54
+		addop 'INPLACE_ADD', 55
+		addop 'INPLACE_SUBTRACT', 56
+		addop 'INPLACE_MULTIPLY', 57
+		addop 'INPLACE_DIVIDE', 58
+		addop 'INPLACE_MODULO', 59
+		addop 'STORE_SUBSCR', 60
+		addop 'DELETE_SUBSCR', 61
+
+		addop 'BINARY_LSHIFT', 62
+		addop 'BINARY_RSHIFT', 63
+		addop 'BINARY_AND', 64
+		addop 'BINARY_XOR', 65
+		addop 'BINARY_OR', 66
+		addop 'INPLACE_POWER', 67
+		addop 'GET_ITER', 68
+
+		addop 'PRINT_EXPR', 70
+		addop 'PRINT_ITEM', 71
+		addop 'PRINT_NEWLINE', 72
+		addop 'PRINT_ITEM_TO', 73
+		addop 'PRINT_NEWLINE_TO', 74
+		addop 'INPLACE_LSHIFT', 75
+		addop 'INPLACE_RSHIFT', 76
+		addop 'INPLACE_AND', 77
+		addop 'INPLACE_XOR', 78
+		addop 'INPLACE_OR', 79
+		addop 'BREAK_LOOP', 80
+		addop 'WITH_CLEANUP', 81
+		addop 'LOAD_LOCALS', 82
+		addop 'RETURN_VALUE', 83
+		addop 'IMPORT_STAR', 84
+		addop 'EXEC_STMT', 85
+		addop 'YIELD_VALUE', 86
+		addop 'POP_BLOCK', 87
+		addop 'END_FINALLY', 88
+		addop 'BUILD_CLASS', 89
+
+		#addop 'HAVE_ARGUMENT', 90      #/* Opcodes from here have an argument: */
+
+		addop 'STORE_NAME', 90      #/* Index in name list */
+		addop 'DELETE_NAME', 91      #/* "" */
+		addop 'UNPACK_SEQUENCE', 92      #/* Number of sequence items */
+		addop 'FOR_ITER', 93, :setip
+		addop 'LIST_APPEND', 94
+
+		addop 'STORE_ATTR', 95      #/* Index in name list */
+		addop 'DELETE_ATTR', 96      #/* "" */
+		addop 'STORE_GLOBAL', 97      #/* "" */
+		addop 'DELETE_GLOBAL', 98      #/* "" */
+		addop 'DUP_TOPX', 99      #/* number of items to duplicate */
+		addop 'LOAD_CONST', 100     #/* Index in const list */
+		addop 'LOAD_NAME', 101     #/* Index in name list */
+		addop 'BUILD_TUPLE', 102     #/* Number of tuple items */
+		addop 'BUILD_LIST', 103     #/* Number of list items */
+		addop 'BUILD_SET', 104     #/* Number of set items */
+		addop 'BUILD_MAP', 105     #/* Always zero for now */
+		addop 'LOAD_ATTR', 106     #/* Index in name list */
+		addop 'COMPARE_OP', 107, :cmp     #/* Comparison operator */
+		addop 'IMPORT_NAME', 108     #/* Index in name list */
+		addop 'IMPORT_FROM', 109     #/* Index in name list */
+		addop 'JUMP_FORWARD', 110, :setip, :stopexec     #/* Number of bytes to skip */
+
+		addop 'JUMP_IF_FALSE_OR_POP', 111, :setip #/* Target byte offset from beginning of code */
+		addop 'JUMP_IF_TRUE_OR_POP', 112, :setip #/* "" */
+		addop 'JUMP_ABSOLUTE', 113, :setip, :stopexec     #/* "" */
+		addop 'POP_JUMP_IF_FALSE', 114, :setip   #/* "" */
+		addop 'POP_JUMP_IF_TRUE', 115, :setip    #/* "" */
+
+		addop 'LOAD_GLOBAL', 116     #/* Index in name list */
+
+		addop 'CONTINUE_LOOP', 119     #/* Start of loop (absolute) */
+		addop 'SETUP_LOOP', 120     #/* Target address (relative) */
+		addop 'SETUP_EXCEPT', 121     #/* "" */
+		addop 'SETUP_FINALLY', 122     #/* "" */
+
+		addop 'LOAD_FAST', 124     #/* Local variable number */
+		addop 'STORE_FAST', 125     #/* Local variable number */
+		addop 'DELETE_FAST', 126     #/* Local variable number */
+
+		addop 'RAISE_VARARGS', 130     #/* Number of raise arguments (1, 2 or 3) */
+		#/* CALL_FUNCTION_XXX opcodes defined below depend on this definition */
+		addop 'CALL_FUNCTION', 131, :u8, :u8, :setip     #/* #args + (#kwargs<<8) */
+		addop 'MAKE_FUNCTION', 132     #/* #defaults */
+		addop 'BUILD_SLICE', 133     #/* Number of items */
+
+		addop 'MAKE_CLOSURE', 134     #/* #free vars */
+		addop 'LOAD_CLOSURE', 135     #/* Load free variable from closure */
+		addop 'LOAD_DEREF', 136     #/* Load and dereference from closure cell */
+		addop 'STORE_DEREF', 137     #/* Store into cell */
+
+		#/* The next 3 opcodes must be contiguous and satisfy (CALL_FUNCTION_VAR - CALL_FUNCTION) & 3 == 1  */
+		addop 'CALL_FUNCTION_VAR', 140, :u8, :u8, :setip  #/* #args + (#kwargs<<8) */
+		addop 'CALL_FUNCTION_KW', 141, :u8, :u8, :setip  #/* #args + (#kwargs<<8) */
+		addop 'CALL_FUNCTION_VAR_KW', 142, :u8, :u8, :setip  #/* #args + (#kwargs<<8) */
+
+		addop 'SETUP_WITH', 143
+
+		#/* Support for opargs more than 16 bits long */
+		addop 'EXTENDED_ARG', 145
+
+		addop 'SET_ADD', 146
+		addop 'MAP_ADD', 147
+	end
+end
+end

data/{lib/metasm → metasm/cpu}/sh4.rb

@@ -5,4 +5,4 @@
 
 
 require 'metasm/main'
-require 'metasm/sh4/decode'
+require 'metasm/cpu/sh4/decode'

data/{lib/metasm → metasm/cpu}/sh4/decode.rb

@@ -3,7 +3,7 @@
 #
 #    Licence is LGPL, see LICENCE in the top-level directory
 
-require 'metasm/sh4/opcodes'
+require 'metasm/cpu/sh4/opcodes'
 require 'metasm/decode'
 
 module Metasm
@@ -39,7 +39,7 @@ class Sh4
 	end
 
 	def decode_findopcode(edata)
-		return if edata.ptr >= edata.data.length
+		return if edata.ptr >= edata.length
 
 		di = DecodedInstruction.new(self)
 		val = edata.decode_imm(:u16, @endianness)
@@ -110,7 +110,6 @@ class Sh4
 			when :pr; PR.new
 			when :fpul; FPUL.new
 			when :fpscr; FPSCR.new
-			when :dbr; DBR.new
 			when :pc; PC.new
 
 			when :@rm, :@rn, :@disppc
@@ -137,25 +136,49 @@ class Sh4
 		}
 
 		di.bin_length += edata.ptr - before_ptr
+
+		return if edata.ptr > edata.length
+
 		di
 	end
 
 	def disassembler_default_func
 		df = DecodedFunction.new
 		df.backtrace_binding = {}
-		15.times { |i| df.backtrace_binding["r#{i}".to_sym] = Expression::Unknown }
+		(0..7 ).each { |i| r = "r#{i}".to_sym ; df.backtrace_binding[r] = Expression::Unknown }
+		(8..15).each { |i| r = "r#{i}".to_sym ; df.backtrace_binding[r] = Expression[r] }
 		df.backtracked_for = [BacktraceTrace.new(Expression[:pr], :default, Expression[:pr], :x)]
 		df.btfor_callback = lambda { |dasm, btfor, funcaddr, calladdr|
 			if funcaddr != :default
 				btfor
 			elsif di = dasm.decoded[calladdr] and di.opcode.props[:saveip]
 				btfor
-			else []
+			else
+				[]
 			end
 		}
 		df
 	end
 
+	def backtrace_update_function_binding(dasm, faddr, f, retaddrlist, *wantregs)
+		retaddrlist.map! { |retaddr| dasm.decoded[retaddr] ? dasm.decoded[retaddr].block.list.last.address : retaddr } if retaddrlist
+		b = f.backtrace_binding
+
+		bt_val = lambda { |r|
+			next if not retaddrlist
+			bt = []
+			b[r] = Expression::Unknown	# break recursive dep
+			retaddrlist.each { |retaddr|
+				bt |= dasm.backtrace(Expression[r], retaddr,
+					:include_start => true, :snapshot_addr => faddr, :origin => retaddr)
+			}
+			b[r] = ((bt.length == 1) ? bt.first : Expression::Unknown)
+		}
+		wantregs = GPR::Sym if wantregs.empty?
+		wantregs.map { |r| r.to_sym }.each(&bt_val)
+	end
+
+
 	# interprets a condition code (in an opcode name) as an expression
 	def decode_cmp_expr(di, a0, a1)
 		case di.opcode.name
@@ -197,6 +220,7 @@ class Sh4
 			when 'stc.w', 'stc.b', 'mov.w', 'mov.b'
 				lambda { |di, a0, a1| { a1 => Expression[a0, :&, mask[di]] }}
 			when 'movt'; lambda { |di, a0| { a0 => :t_bit }}
+			when 'mova'; lambda { |di, a0, a1| { a1 => Expression[a0] }}
 			when 'exts.b', 'exts.w', 'extu.w'
 				lambda { |di, a0, a1| { a1 => Expression[a0, :&, mask[di]] }}
 			when 'cmp/eq', 'cmp/ge', 'cmp/ge', 'cmp/gt', 'cmp/hi', 'cmp/hs'
@@ -212,12 +236,12 @@ class Sh4
 			when 'clrt'; lambda { |di| { :t_bit => 0 }}
 			when 'clrmac'; lambda { |di| { :macl => 0, :mach => 0 }}
 			when 'jmp'; lambda { |di, a0| { :pc => a0 }}
-			when 'jsr'; lambda { |di, a0| { :pc => Expression[a0], :pr => Expression[di.address+2*2] }}
+			when 'jsr', 'bsr', 'bsrf'; lambda { |di, a0| { :pc => Expression[a0], :pr => Expression[di.address, :+, 2*2] }}
 			when 'dt'; lambda { |di, a0|
 				res = Expression[a0, :-, 1]
 				{ :a0 => res, :t_bit => Expression[res, :==, 0] }
 			}
-			when 'add' ; lambda { |di, a0, a1| { a1 => Expression[a0, :+, a1] }}
+			when 'add' ; lambda { |di, a0, a1| { a1 => Expression[[a0, :+, a1], :&, 0xffff_ffff] }}
 			when 'addc' ; lambda { |di, a0, a1|
 				res = Expression[[a0, :&, mask[di]], :+, [[a1, :&, mask[di]], :+, :t_bit]]
 				{ a1 => Expression[a0, :+, [a1, :+, :t_bit]], :t_bit => Expression[res, :>, mask[di]] }
@@ -252,17 +276,16 @@ class Sh4
 				shift_bit = Expression[a0, :&, 1]
 				{ a0 => Expression[a0, :>>, 1], :t_bit => shift_bit }
 			}
-			when 'sub';  lambda { |di, a0, a1| { a1 => Expression[a0, :-, a1] }}
-			when 'subc'; lambda { |di, a0, a1| { a1 => Expression[a0, :-, [a1, :-, :t_bit]] }}
+			when 'sub';  lambda { |di, a0, a1| { a1 => Expression[[a1, :-, a0], :&, 0xffff_ffff] }}
+			when 'subc'; lambda { |di, a0, a1| { a1 => Expression[a1, :-, [a0, :-, :t_bit]] }}
 			when 'and', 'and.b'; lambda { |di, a0, a1| { a1 => Expression[[a0, :&, mask[di]], :|, [[a1, :&, mask[di]]]] }}
 			when 'or', 'or.b';   lambda { |di, a0, a1| { a1 => Expression[[a0, :|, mask[di]], :|, [[a1, :&, mask[di]]]] }}
 			when 'xor', 'xor.b'; lambda { |di, a0, a1| { a1 => Expression[[a0, :|, mask[di]], :^, [[a1, :&, mask[di]]]] }}
-			when 'add', 'addc', 'addv'; lambda { |di, a0, a1| { a1 => Expression[a0, :+, a1] }}
 			when 'neg' ;  lambda { |di, a0, a1| { a1 => Expression[mask[di], :-, a0] }}
 			when 'negc' ; lambda { |di, a0, a1| { a1 => Expression[[[mask[di], :-, a0], :-, :t_bit], :&, mask[di]] }}
 			when 'not';   lambda { |di, a0, a1| { a1 => Expression[a0, :^, mask[di]] }}
-			when 'nop'; lambda { {} }
-			when /^b/; lambda { {} }	# branches
+			when 'nop'; lambda { |*a| {} }
+			when /^b/; lambda { |*a| {} }	# branches
 			end
 		}
 
@@ -283,12 +306,15 @@ class Sh4
 		if binding = backtrace_binding[di.opcode.basename]
 			bd = binding[di, *a] || {}
 			di.instruction.args.grep(Memref).each { |m|
-				if m.post
-					# TODO preincrement/postdecrement
-					bd.each { |k, v| bd[k] = v.bind(r => Expression[r, :+, 1]) }
-					bd[r] ||= Expression[r, :+, 1]
+				next unless r = m.base and r.kind_of?(GPR)
+				r = r.symbolic
+				case m.action
+				when :post
+					bd[r] ||= Expression[r, :+, di.opcode.props[:memsz]/8]
+				when :pre
+					bd[r] ||= Expression[r, :-, di.opcode.props[:memsz]/8]
 				end
-			} if false
+			}
 			bd
 		else
 			puts "unhandled instruction to backtrace: #{di}" if $VERBOSE
@@ -310,6 +336,11 @@ class Sh4
 		      else val
 		      end
 
+		val = case di.instruction.opname
+		      when 'braf', 'bsrf'; Expression[[di.address, :+, 4], :+, val]
+		      else val
+		      end
+
 		[Expression[val]]
 	end
 

data/{lib/metasm → metasm/cpu}/sh4/main.rb

@@ -257,6 +257,8 @@ class Sh4 < CPU
 			b = @base
 			b = b.symbolic if b.kind_of? Reg
 
+			b = Expression[b, :-, sz/8] if @action == :pre
+
 			if disp
 				o = @disp
 				o = o.symbolic if o.kind_of? Reg
@@ -272,12 +274,16 @@ class Sh4 < CPU
 
 		def render
 			if @disp
-				['@(', @base, ',', @disp, ')']
+				#['@(', @base, ',', @disp, ')']
+				['[', @base, '+', @disp, ']']
 			else
 				case @action
-				when :pre then ['@-', @base]
-				when :post then ['@', @base, '+']
-				else ['@', @base]
+				when :pre then ['[--', @base, ']']
+				when :post then ['[', @base, '++]']
+				else ['[', @base, ']']
+				#when :pre then ['@-', @base]
+				#when :post then ['@', @base, '+']
+				#else ['@', @base]
 				end
 			end
 		end
@@ -288,5 +294,8 @@ class Sh4 < CPU
 		init
 	end
 
+	def dbg_register_list
+		@dbg_register_list ||= GPR::Sym
+	end
 end
 end

data/{lib/metasm → metasm/cpu}/sh4/opcodes.rb

@@ -3,18 +3,17 @@
 #
 #    Licence is LGPL, see LICENCE in the top-level directory
 
-require 'metasm/sh4/main'
+require 'metasm/cpu/sh4/main'
 
 module Metasm
 class Sh4
 	def addop(name, bin, *args)
 		o = Opcode.new name, bin
 
-		o.args.concat(args & @fields_mask.keys)
-		(args & @valid_props).each { |p| o.props[p] = true }
-
-		(args & @fields_mask.keys).each { |f|
-			o.fields[f] = [@fields_mask[f], @fields_shift[f]]
+		args.each { |a|
+			o.args << a if @fields_mask[a]
+			o.props[a] = true if @valid_props[a]
+			o.fields[a] = [@fields_mask[a], @fields_shift[a]] if @fields_mask[a]
 		}
 
 		@opcode_list << o
@@ -74,7 +73,7 @@ class Sh4
 		# implicit operands
 		[:vbr, :gbr, :sr, :ssr, :spc, :sgr, :dbr, :mach, :macl, :pr, :fpul, :fpscr, :dbr, :pc, :r0].each { |a| @fields_mask[a] = @fields_shift[a] = 0 }
 
-		@valid_props = [:setip, :saveip, :stopexec , :delay_slot]
+		@valid_props[:delay_slot] = true
 
 		addop 'add', 0b0011 << 12 | 0b1100, :rm, :rn
 		addop 'add', 0b0111 << 12, :s8, :rn
@@ -275,7 +274,7 @@ class Sh4
 		addop 'mov.w', 0b10000101 << 8, :@disprm, :r0
 
 		addop 'mova', 0b11000111 << 8, :disppc, :r0 # calculates an effective address using PC-relative with displacement addressing
-		addop 'movca.l', 0b0000 << 12 | 11000011, :r0, :@rn # stores the long-word in R0 to memory at the effective address specified in Rn.     
+		addop 'movca.l', 0b0000 << 12 | 11000011, :r0, :@rn # stores the long-word in R0 to memory at the effective address specified in Rn.
 
 		addop 'movt', 0b0000 << 12 | 0b00101001, :rn # copies the T-bit to Rn