metasm 1.0.1 → 1.0.2

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

@@ -4,7 +4,7 @@
 #    Licence is LGPL, see LICENCE in the top-level directory
 
 
-require 'metasm/pic16c/main'
+require 'metasm/cpu/pic16c/main'
 
 module Metasm
 class Pic16c

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

@@ -5,7 +5,7 @@
 
 
 require 'metasm/main'
-require 'metasm/mips/parse'
-require 'metasm/mips/encode'
-require 'metasm/mips/decode'
-require 'metasm/mips/render'
+require 'metasm/cpu/ppc/parse'
+require 'metasm/cpu/ppc/encode'
+require 'metasm/cpu/ppc/decode'
+require 'metasm/cpu/ppc/decompile'

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

@@ -4,7 +4,7 @@
 #    Licence is LGPL, see LICENCE in the top-level directory
 
 
-require 'metasm/ppc/opcodes'
+require 'metasm/cpu/ppc/opcodes'
 require 'metasm/decode'
 
 module Metasm
@@ -13,8 +13,8 @@ class PowerPC
 		# bit = 0 if can be mutated by an field value, 1 if fixed by opcode
 		return if not op.bin.kind_of? Integer
 		op.bin_mask = 0
-		op.args.each { |f|
-			op.bin_mask |= @fields_mask[f] << @fields_shift[f]
+		op.fields.each { |k, (m, s)|
+			op.bin_mask |= m << s
 		}
 		op.bin_mask = 0xffff_ffff ^ op.bin_mask
 	end
@@ -37,7 +37,7 @@ class PowerPC
 	end
 
 	def decode_findopcode(edata)
-		return if edata.ptr >= edata.data.length
+		return if edata.ptr+4 > edata.length
 		di = DecodedInstruction.new(self)
 		val = edata.decode_imm(:u32, @endianness)
 		edata.ptr -= 4
@@ -67,14 +67,20 @@ class PowerPC
 			when :fra, :frb, :frc, :frs, :frt; FPR.new field_val[a]
 			when :ra_i16, :ra_i16s, :ra_i16q
 				i = field_val[{:ra_i16 => :d, :ra_i16s => :ds, :ra_i16q => :dq}[a]]
-			       	Memref.new GPR.new(field_val[:ra]), Expression[i]
-			when :bd, :d, :ds, :dq, :si, :ui, :li, :sh, :ma, :mb, :me, :ma_, :mb_, :me_; Expression[field_val[a]]
-			when :ign_bo_zzz, :ign_bo_z, :ign_bo_at, :ign_bo_at2, :ign_bi, :aa, :lk, :oe, :rc, :l; next
+				Memref.new GPR.new(field_val[:ra]), Expression[i]
+			when :bd, :d, :ds, :dq, :si, :ui, :li, :sh, :mb, :me, :mb_, :me_, :u; Expression[field_val[a]]
+			when :ba, :bf, :bfa, :bt; CR.new field_val[a]
+			when :bb, :bh, :flm, :fxm, :l_, :l__, :lev, :nb, :sh_, :spr, :sr, :tbr, :th, :to
+				puts "PPC.decode: unsupported argument #{a.inspect}" if $VERBOSE	# TODO
+				Expression[field_val[a]]
 			else raise SyntaxError, "Internal error: invalid argument #{a} in #{op.name}"
 			end
 		}
+
 		di.bin_length += edata.ptr - before_ptr
 
+		return if edata.ptr > edata.length
+
 		decode_aliases(di.instruction)
 
 		di
@@ -84,8 +90,8 @@ class PowerPC
 		case i.opname
 		when /^n?or\.?$/
 			if i.args[1] == i.args[2]
-	 			i.args.pop
-	 			i.opname = {'or' => 'mr', 'or.' => 'mr.', 'nor' => 'not', 'nor.' => 'not.'}[i.opname]
+				i.args.pop
+				i.opname = {'or' => 'mr', 'or.' => 'mr.', 'nor' => 'not', 'nor.' => 'not.'}[i.opname]
 			end
 		when /^addi/
 			if a = i.args[2].reduce and a.kind_of? Integer and a < 0
@@ -107,7 +113,7 @@ class PowerPC
 	# else just add the offset +off+ of the instruction + its length (off may be an Expression)
 	# assumes edata.ptr points just after the instruction (as decode_instr_op left it)
 	# do not call twice on the same di !
- 	def decode_instr_interpret(di, addr)
+	def decode_instr_interpret(di, addr)
 		if di.opcode.props[:setip] and di.instruction.args.last.kind_of? Expression and di.opcode.name[0] != ?t and di.opcode.name[-1] != ?a
 			arg = Expression[addr, :+, di.instruction.args.last].reduce
 			di.instruction.args[-1] = Expression[arg]
@@ -191,11 +197,11 @@ class PowerPC
 				ptr = m.pointer.externals.grep(Symbol).first
 				ret[ptr] = m.pointer if ptr != a0
 				ret
-		       	}
+			}
 			when 'lwz'; lambda { |di, a0, m| { a0 => Expression[m] } }
 			when 'stwu'; lambda { |di, a0, m|
 				{ m => Expression[a0], m.pointer.externals.grep(Symbol).first => m.pointer }
-		       	}
+			}
 			when 'stw'; lambda { |di, a0, m| { m => Expression[a0] } }
 			when 'rlwinm'; lambda { |di, a0, a1, sh, mb, me|
 				mb, me = mb.reduce, me.reduce

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

@@ -4,7 +4,7 @@
 #    Licence is LGPL, see LICENCE in the top-level directory
 
 
-require 'metasm/ppc/main'
+require 'metasm/cpu/ppc/main'
 
 module Metasm
 class PowerPC
@@ -25,7 +25,7 @@ class PowerPC
 	# returns { blockaddr => [list of vars that are needed by a following block] }
 	def decompile_func_finddeps(dcmp, blocks, func)
 		deps_r = {} ; deps_w = {} ; deps_to = {}
-		deps_subfunc = {} 	# things read/written by subfuncs
+		deps_subfunc = {}	# things read/written by subfuncs
 
 		# find read/writes by each block
 		blocks.each { |b, to|
@@ -43,7 +43,7 @@ class PowerPC
 					end
 				}
 				#a << :eax if di.opcode.name == 'ret'		# standard ABI
-				
+
 				deps_r[b] |= a.map { |ee| Expression[ee].externals.grep(::Symbol) }.flatten - [:unknown] - deps_w[b]
 				deps_w[b] |= w.map { |ee| Expression[ee].externals.grep(::Symbol) }.flatten - [:unknown]
 			}

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

@@ -4,7 +4,7 @@
 #    Licence is LGPL, see LICENCE in the top-level directory
 
 
-require 'metasm/ppc/opcodes'
+require 'metasm/cpu/ppc/opcodes'
 require 'metasm/encode'
 
 module Metasm
@@ -31,7 +31,7 @@ class PowerPC
 
 		op.args.zip(instr.args).each { |sym, arg|
 			case sym
-			when :rs, :rt, :rd
+			when :rs, :rt, :rd, :ba, :bf, :bfa, :bt
 				set_field[sym, arg.i]
 			when :ft
 				set_field[sym, arg.i]

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
+		@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 ; Sym[@i] end
-		def render ; [@i == 1 ? 'sp' : "r#@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
@@ -50,14 +52,15 @@ class PowerPC < CPU
 	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
@@ -73,8 +76,10 @@ class PowerPC < CPU
 			@i = 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 ; "cr#@i".to_sym end
-		def render ; ["cr#@i"] end
 	end
 
 	# indirection : reg+reg or reg+16b_off
@@ -89,13 +94,13 @@ class PowerPC < CPU
 			b = @base.symbolic
 			b = nil if b == :r0	# XXX is it true ?
 			o = @offset
-			o = o.symbolic if o.kind_of? Reg
+			o = o.symbolic if o.kind_of?(Reg)
 			Indirection[Expression[b, :+, o].reduce, 4, orig]
 		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
 
@@ -113,6 +116,9 @@ class PowerPC
 			:tbr => 0x3FF, :th => 15, :to => 31, :u => 15, :ui => 0xFFFF,
 			:ign_bo_zzz => 0b101111111, :ign_bo_z => 1, :ign_bo_at => 3, :ign_bo_at2 => 0b100111111
 
+		@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 }
+
 		@fields_shift[:ra_i16]  = @fields_shift[:ra_i16s] = @fields_shift[:ra_i16q] = 0
 		@fields_mask[:ra_i16]  = (@fields_mask[:d]  << @fields_shift[:d]) | (@fields_mask[:ra] << @fields_shift[:ra])
 		@fields_mask[:ra_i16s] = (@fields_mask[:ds] << @fields_shift[:d]) | (@fields_mask[:ra] << @fields_shift[:ra])
@@ -123,7 +129,7 @@ class PowerPC
 		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,136 @@
+#    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 backtrace_binding
+		@backtrace_binding ||= init_backtrace_binding
+	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_backtrace_binding(di)
+		a = di.instruction.args.map { |arg|
+			case arg
+			when Var; arg.symbolic
+			else arg
+			end
+		}
+
+		if binding = backtrace_binding[di.opcode.basename]
+			binding[di, *a]
+		else
+			puts "unhandled instruction to backtrace: #{di}" if $VERBOSE
+			{ :incomplete_binding => Expression[1] }
+		end
+	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