metasm 1.0.0 → 1.0.5

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

@@ -11,10 +11,15 @@ module Metasm
 class PowerPC < CPU
 	class Reg
 		include Renderable
+		class << self
+			attr_accessor :s_to_i, :i_to_s
+		end
 
 		def ==(o)
 			o.class == self.class and (not respond_to?(:i) or o.i == i)
 		end
+
+		def render ; [self.class.i_to_s[@i]] ; end
 	end
 
 	# general purpose reg
@@ -24,17 +29,14 @@ class PowerPC < CPU
 			@i = i
 		end
 
-		Sym = (0..31).map { |i| "r#{i}".to_sym }
-		Sym[1] = :sp
-		def symbolic ; Sym[@i] end
-		def render ; [@i == 1 ? 'sp' : "r#@i"] end
+		@s_to_i = (0..31).inject({}) { |h, i| h.update((i == 1 ? 'sp' : "r#{i}") => i) }
+		@i_to_s = @s_to_i.invert
+		Sym = @s_to_i.sort.transpose.last
+		def symbolic(di=nil) ; Sym[@i] end
 	end
 
 	# special purpose reg
 	class SPR < Reg
-		class << self
-			attr_accessor :s_to_i, :i_to_s
-		end
 		@s_to_i = {'xer' => 1, 'lr' => 8, 'ctr' => 9, 'dec' => 22, 'srr0' => 26, 'srr1' => 27,
 			'sprg0' => 272, 'sprg1' => 273, 'sprg2' => 274, 'sprg3' => 275, 'pvr' => 287}
 		@i_to_s = @s_to_i.invert
@@ -45,24 +47,25 @@ class PowerPC < CPU
 		end
 
 		Sym = @i_to_s.sort.inject({}) { |h, (k, v)| h.update k => v.to_sym }
-		def symbolic ; Sym[@i] end
+		def symbolic(di=nil) ; Sym[@i] end
 		def render ; [self.class.i_to_s[@i] || "spr#@i"] end
 	end
 
 	# floating point
-	class FPR
+	class FPR < Reg
 		attr_accessor :i
 		def initialize(i)
 			@i = i
 		end
 
-		include Renderable
-		def render ; ["fp#@i"] end
+		@s_to_i = (0..31).inject({}) { |h, i| h.update "fp#{i}" => i }
+		@i_to_s = @s_to_i.invert
+		Sym = @s_to_i.sort.transpose.last
 	end
 
 	# machine state reg
 	class MSR < Reg
-		def symbolic ; :msr end
+		def symbolic(di=nil) ; :msr end
 		def render ; ['msr'] end
 	end
 
@@ -73,8 +76,10 @@ class PowerPC < CPU
 			@i = i
 		end
 
-		def symbolic ; "cr#@i".to_sym end
-		def render ; ["cr#@i"] end
+		@s_to_i = (0..31).inject({}) { |h, i| h.update "cr#{i}" => i }
+		@i_to_s = @s_to_i.invert
+		Sym = @s_to_i.sort.transpose.last
+		def symbolic(di=nil) ; "cr#@i".to_sym end
 	end
 
 	# indirection : reg+reg or reg+16b_off
@@ -85,17 +90,17 @@ class PowerPC < CPU
 			@base, @offset = base, offset
 		end
 
-		def symbolic(orig)
+		def symbolic(di=nil)
 			b = @base.symbolic
 			b = nil if b == :r0	# XXX is it true ?
 			o = @offset
-			o = o.symbolic if o.kind_of? Reg
-			Indirection[Expression[b, :+, o].reduce, 4, orig]
+			o = o.symbolic if o.kind_of?(Reg)
+			Indirection[Expression[b, :+, o].reduce, 4, (di.address if di)]
 		end
 
 		include Renderable
 		def render
-			if @offset.kind_of? Reg
+			if @offset.kind_of?(Reg)
 				['(', @base, ' + ', @offset, ')']
 			else
 				[@offset, '(', @base, ')']

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

@@ -4,14 +4,17 @@
 #    Licence is LGPL, see LICENCE in the top-level directory
 
 
-require 'metasm/ppc/main'
+require 'metasm/cpu/ppc/main'
 
 module Metasm
 class PowerPC
 	def addop(name, bin, *argprops)
-		o = Opcode.new name, bin 
-		o.args.concat(argprops & @fields_mask.keys)
-		(argprops & @valid_props).each { |p| o.props[p] = true }
+		o = Opcode.new name, bin
+		argprops.each { |a|
+			o.args << a if @valid_args[a]
+			o.fields[a] = [@fields_mask[a], @fields_shift[a]] if @fields_mask[a]
+			o.props[a] = true if @valid_props[a]
+		}
 		@opcode_list << o
 	end
 
@@ -36,7 +39,7 @@ class PowerPC
 		addop_branch(nbase+'dz',  bin|(0b10010<<21), :ign_bo_at2, :stopexec, *argprops) if not argprops.include? :ctr
 		addop_branch(nbase+'dnz', bin|(0b10000<<21), :ign_bo_at2, :stopexec, *argprops) if not argprops.include? :ctr
 
-		# conditionnal
+		# conditional
 		%w[lt gt eq so].each_with_index { |cd, i|
 			ncd = {'lt' => 'gte', 'gt' => 'lte', 'eq' => 'ne', 'so' => 'nso'}[cd]
 			addop_branch(nbase+cd, bin|(0b1100<<21)|(i<<16), :ign_bo_at, *argprops)
@@ -118,12 +121,14 @@ class PowerPC
 		@fields_mask[:ra_i16s] = (@fields_mask[:ds] << @fields_shift[:d]) | (@fields_mask[:ra] << @fields_shift[:ra])
 		@fields_mask[:ra_i16q] = (@fields_mask[:dq] << @fields_shift[:d]) | (@fields_mask[:ra] << @fields_shift[:ra])
 
+		@valid_args = @fields_mask.dup
+		[:ign_bo_zzz, :ign_bo_z, :ign_bo_at, :ign_bo_at2, :aa, :lk, :oe, :rc, :l].each { |k| @valid_args.delete k }
 
 		addop_branch 'b', 0x48000000, :li, :stopexec
 		addop_branchcond 'b', 0x40000000, :bd
 		addop_branchcond 'b', 0x4C000020, :lr
 		addop_branchcond 'b', 0x4C000420, :ctr
-	
+
 		addop 'sc',     0x44000002, :lev
 		addop 'crand',  0x4C000202, :bt, :ba, :bb
 		addop 'crxor',  0x4C000182, :bt, :ba, :bb

data/metasm/cpu/ppc/parse.rb

@@ -0,0 +1,55 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2009 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+
+require 'metasm/cpu/ppc/opcodes'
+require 'metasm/parse'
+
+module Metasm
+class PowerPC
+# TODO
+	def parse_arg_valid?(op, sym, arg)
+		case sym
+		when :ra, :rb, :rs, :rt; arg.kind_of?(GPR)
+		when :fra, :frb, :frc, :frs, :frt; arg.kind_of?(FPR)
+		when :ra_i16, :ra_i16s, :ra_i16q; arg.kind_of?(Memref)
+		when :bd, :d, :ds, :dq, :si, :ui, :li, :sh, :mb, :me, :mb_, :me_, :u; arg.kind_of?(Expression)
+		when :ba, :bf, :bfa, :bt; arg.kind_of?(CR)
+		when :ign_bo_zzz, :ign_bo_z, :ign_bo_at, :ign_bo_at2, :aa, :lk, :oe, :rc, :l; # ?
+		when :bb, :bh, :flm, :fxm, :l_, :l__, :lev, :nb, :sh_, :spr, :sr, :tbr, :th, :to
+			# TODO
+		else raise "internal error: mips arg #{sym.inspect}"
+		end
+	end
+
+	def parse_argument(pgm)
+		pgm.skip_space
+		return if not tok = pgm.readtok
+		if tok.type == :string
+			return GPR.new(GPR.s_to_i[tok.raw]) if GPR.s_to_i[tok.raw]
+			return SPR.new(SPR.s_to_i[tok.raw]) if SPR.s_to_i[tok.raw]
+			return FPR.new(FPR.s_to_i[tok.raw]) if FPR.s_to_i[tok.raw]
+			return CR.new(CR.s_to_i[tok.raw]) if CR.s_to_i[tok.raw]
+			return MSR.new if tok.raw == 'msr'
+		end
+		pgm.unreadtok tok
+		arg = Expression.parse pgm
+		pgm.skip_space
+		# check memory indirection: 'off(base reg)'	# XXX scaled index ?
+		if arg and pgm.nexttok and pgm.nexttok.type == :punct and pgm.nexttok.raw == '('
+			pgm.readtok
+			pgm.skip_space_eol
+			ntok = pgm.readtok
+			raise tok, "Invalid base #{ntok}" unless ntok and ntok.type == :string and GPR.s_to_i[ntok.raw]
+			base = GPR.new GPR.s_to_i[ntok.raw]
+			pgm.skip_space_eol
+			ntok = pgm.readtok
+			raise tok, "Invalid memory reference, ')' expected" if not ntok or ntok.type != :punct or ntok.raw != ')'
+			arg = Memref.new base, arg
+		end
+		arg
+	end
+end
+end

data/metasm/cpu/python.rb

@@ -0,0 +1,8 @@
+#    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'
+require 'metasm/cpu/python/decode'

data/metasm/cpu/python/decode.rb

@@ -0,0 +1,116 @@
+#    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/opcodes'
+require 'metasm/decode'
+
+module Metasm
+class Python
+	def build_bin_lookaside
+		opcode_list.inject({}) { |la, op| la.update op.bin => op }
+	end
+
+	def decode_findopcode(edata)
+		di = DecodedInstruction.new(self)
+
+		byte = edata.decode_imm(:u8, :little)
+
+		di if di.opcode = @bin_lookaside[byte]
+	end
+
+	def decode_instr_op(edata, di)
+		di.bin_length = 1
+
+		di.instruction.opname = di.opcode.name
+
+		di.opcode.args.each { |a|
+			case a
+			when :cmp
+				di.bin_length += 2
+				v = edata.decode_imm(:i16, @endianness)
+				di.instruction.args << (CMP_OP[v] || Expression[v])
+			when :i16
+				di.bin_length += 2
+				di.instruction.args << Expression[edata.decode_imm(:i16, @endianness)]
+			when :u8
+				di.bin_length += 1
+				di.instruction.args << Expression[edata.decode_imm(:u8, @endianness)]
+			else
+				raise "unsupported arg #{a.inspect}"
+			end
+		}
+
+		return if edata.ptr > edata.length
+
+		di
+	end
+
+	def decode_instr_interpret(di, addr)
+		case di.opcode.name
+		when 'LOAD_CONST'
+			if c = prog_code(addr)
+				cst = c[:consts][di.instruction.args.first.reduce]
+				if cst.kind_of? Hash and cst[:type] == :code
+					di.add_comment "lambda #{Expression[cst[:fileoff]]}"
+				else
+					di.add_comment cst.inspect
+				end
+			end
+		when 'LOAD_NAME', 'LOAD_ATTR', 'LOAD_GLOBAL', 'STORE_NAME', 'IMPORT_NAME', 'LOAD_FAST'
+			if c = prog_code(addr)
+				di.add_comment c[:names][di.instruction.args.first.reduce].inspect
+			end
+		end
+		di
+	end
+
+	def init_backtrace_binding
+		@backtrace_binding ||= {}
+
+		opcode_list.each { |op|
+			binding = case op
+				  when 'nop'; lambda { |*a| {} }
+				  end
+			@backtrace_binding[op] ||= binding if binding
+		}
+
+		@backtrace_binding
+	end
+
+	def get_xrefs_x(dasm, di)
+		return [] if not di.opcode.props[:setip]
+
+		arg =	case di.opcode.name
+			when 'JUMP_FORWARD', 'FOR_ITER'
+				# relative offset
+				di.instruction.args.last.reduce + di.next_addr
+			when 'CALL_FUNCTION_VAR'
+				'lol'
+			when /CALL/
+					:unknown
+			else
+				# absolute offset from :code start
+				off = di.instruction.args.last.reduce
+				if c = prog_code(di)
+					off += c[:fileoff]
+				end
+				off
+			end
+
+		[Expression[(arg.kind_of?(Var) ? arg.symbolic : arg)]]
+	end
+
+	def prog_code(addr)
+		addr = addr.address if addr.kind_of? DecodedInstruction
+		@last_prog_code ||= nil
+		return @last_prog_code if @last_prog_code and @last_prog_code[:fileoff] <= addr and @last_prog_code[:fileoff] + @last_prog_code[:code].length > addr
+		@last_prog_code = @program.code_at_off(addr) if @program
+	end
+
+	def backtrace_is_function_return(expr, di=nil)
+		#Expression[expr].reduce == Expression['wtf']
+	end
+end
+end

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(di=nil); "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