metasm 1.0.0

data/lib/metasm/mips.rb

@@ -0,0 +1,11 @@
+#    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/main'
+require 'metasm/mips/parse'
+require 'metasm/mips/encode'
+require 'metasm/mips/decode'
+require 'metasm/mips/render'

data/lib/metasm/mips/compile_c.rb

@@ -0,0 +1,7 @@
+#    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/mips/parse'
+require 'metasm/compile_c'

data/lib/metasm/mips/decode.rb

@@ -0,0 +1,253 @@
+#    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/mips/opcodes'
+require 'metasm/decode'
+
+module Metasm
+class MIPS
+	def build_opcode_bin_mask(op)
+		# bit = 0 if can be mutated by an field value, 1 if fixed by opcode
+		op.bin_mask = 0
+		op.args.each { |f|
+			op.bin_mask |= @fields_mask[f] << @fields_shift[f]
+		}
+		op.bin_mask = 0xffffffff ^ op.bin_mask
+	end
+
+	def build_bin_lookaside
+		lookaside = Array.new(256) { [] }
+		opcode_list.each { |op|
+			build_opcode_bin_mask op
+
+			b   = op.bin >> 24
+			msk = op.bin_mask >> 24
+
+			for i in b..(b | (255^msk))
+				next if i & msk != b & msk
+				lookaside[i] << op
+			end
+		}
+		lookaside
+	end
+
+	def decode_findopcode(edata)
+		return if edata.ptr >= edata.data.length
+		# TODO handle relocations !!
+		di = DecodedInstruction.new(self)
+		val = edata.decode_imm(:u32, @endianness)
+		edata.ptr -= 4
+		di if di.opcode = @bin_lookaside[val >> 24].find { |op|
+			(op.bin & op.bin_mask) == (val & op.bin_mask)
+		}
+	end
+
+	def decode_instr_op(edata, di)
+		# TODO handle relocations !!
+		before_ptr = edata.ptr
+		op = di.opcode
+		di.instruction.opname = op.name
+		val = edata.decode_imm(:u32, @endianness)
+
+		field_val = lambda { |f|
+			r = (val >> @fields_shift[f]) & @fields_mask[f]
+			# XXX do that cleanly (Expr.decode_imm)
+			case f
+			when :sa, :i16, :it; r = Expression.make_signed(r, 16)
+			when :i20; r = Expression.make_signed(r, 20)
+			when :i26; r = Expression.make_signed(r, 26)
+			else r
+			end
+		}
+
+		op.args.each { |a|
+			di.instruction.args << case a
+			when :rs, :rt, :rd; Reg.new field_val[a]
+			when :sa, :i16, :i20, :i26, :it; Expression[field_val[a]]
+			when :rs_i16; Memref.new Reg.new(field_val[:rs]), Expression[field_val[:i16]]
+			when :ft; FpReg.new field_val[a]
+			when :idm1, :idb; Expression['unsupported']
+			else raise SyntaxError, "Internal error: invalid argument #{a} in #{op.name}"
+			end
+		}
+		di.bin_length += edata.ptr - before_ptr
+
+		di
+	end
+
+	# converts relative branch offsets to absolute addresses
+	# 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)
+		if di.opcode.props[:setip] and di.instruction.args.last.kind_of? Expression and di.opcode.name[0] != ?t
+			delta = Expression[di.instruction.args.last, :<<, 2].reduce
+			if di.opcode.args.include? :i26
+				arg = Expression[[[addr, :+, di.bin_length], :&, 0xfc00_0000], :+, delta].reduce
+			else
+				arg = Expression[[addr, :+, di.bin_length], :+, delta].reduce
+			end
+			di.instruction.args[-1] = Expression[arg]
+		end
+
+		di
+	end
+
+	# hash opname => lambda { |di, *sym_args| binding }
+	def backtrace_binding
+		@backtrace_binding ||= init_backtrace_binding
+	end
+	def backtrace_binding=(b) @backtrace_binding = b end
+
+	def init_backtrace_binding
+		@backtrace_binding ||= {}
+		opcode_list.map { |ol| ol.name }.uniq.each { |op|
+			binding = case op
+			when 'break'
+			when 'bltzal', 'bgezal'; lambda { |di, *a|
+				# XXX $ra is set only if branch is taken...
+				{ :$ra => Expression[Expression[di.address, :+, 2*di.bin_length].reduce] }
+			}
+			when 'nop', 'j', 'jr', /^b/; lambda { |di, *a| {} }
+			when 'lui'; lambda { |di, a0, a1| { a0 => Expression[a1, :<<, 16] } }
+			when 'add', 'addu', 'addi', 'addiu'; lambda { |di, a0, a1, a2| { a0 => Expression[a1, :+, a2] } }	# XXX addiu $sp, -40h should be addiu $sp, 0xffc0 from the books, but..
+			when 'sub', 'subu'; lambda { |di, a0, a1, a2| { a0 => Expression[a1, :-, a2] } }
+			when 'slt', 'slti'; lambda { |di, a0, a1, a2| { a0 => Expression[a1, :<, a2] } }
+			when 'and', 'andi'; lambda { |di, a0, a1, a2| { a0 => Expression[a1, :&, a2] } }
+			when 'or', 'ori';   lambda { |di, a0, a1, a2|   { a0 => Expression[a1, :|, a2] } }
+			when 'nor'; lambda { |di, a0, a1, a2| { a0 => Expression[:~, [a1, :|, a2]] } }
+			when 'xor'; lambda { |di, a0, a1, a2| { a0 => Expression[a1, :^, a2] } }
+			when 'sll', 'sllv'; lambda { |di, a0, a1, a2| { a0 => Expression[a1, :>>, a2] } }
+			when 'srl', 'srlv', 'sra', 'srav'; lambda { |di, a0, a1, a2| { a0 => Expression[a1, :<<, a2] } }	# XXX sign-extend
+			when 'lw';        lambda { |di, a0, a1| { a0 => Expression[a1] } }
+			when 'sw';        lambda { |di, a0, a1| { a1 => Expression[a0] } }
+			when 'lh', 'lhu'; lambda { |di, a0, a1| { a0 => Expression[a1] } }	# XXX sign-extend
+			when 'sh';        lambda { |di, a0, a1| { a1 => Expression[a0] } }
+			when 'lb', 'lbu'; lambda { |di, a0, a1| { a0 => Expression[a1] } }
+			when 'sb';        lambda { |di, a0, a1| { a1 => Expression[a0] } }
+			when /^slti?u?/;  lambda { |di, a0, a1, a2| { a0 => Expression[a1, :<, a2] } }	# XXX signedness
+			when 'mfhi'; lambda { |di, a0| { a0 => Expression[:hi] } }
+			when 'mflo'; lambda { |di, a0| { a0 => Expression[:lo] } }
+			when 'mult'; lambda { |di, a0, a1| { :hi => Expression[[a0, :*, a1], :>>, 32], :lo => Expression[[a0, :*, a1], :&, 0xffff_ffff] } }
+			when 'div';  lambda { |di, a0, a1| { :hi => Expression[a0, :%, a1], :lo => Expression[a0, :/, a1] } }
+			when 'jal', 'jalr'; lambda { |di, a0| { :$ra => Expression[Expression[di.address, :+, 2*di.bin_length].reduce] } }
+			when 'li', 'mov'; lambda { |di, a0, a1| { a0 => Expression[a1] } }
+			when 'syscall'; lambda { |di, *a| { :$v0 => Expression::Unknown } }
+			end
+
+			@backtrace_binding[op] ||= binding if binding
+		}
+		@backtrace_binding
+	end
+
+	def get_backtrace_binding(di)
+		a = di.instruction.args.map { |arg|
+			case arg
+			when Memref; arg.symbolic(di.address)
+			when Reg; arg.symbolic
+			else arg
+			end
+		}
+
+		binding = if binding = backtrace_binding[di.instruction.opname]
+			binding[di, *a]
+		else
+			if di.instruction.opname[0] == ?b and di.opcode.props[:setip]
+			else
+				puts "unknown instruction to emu #{di}" if $VERBOSE
+			end
+			{}
+		end
+
+		binding.delete 0	# allow add $zero, 42 => nop
+
+		binding
+	end
+
+	def get_xrefs_x(dasm, di)
+		return [] if not di.opcode.props[:setip]
+
+		arg = di.instruction.args.last
+		[Expression[
+		case arg
+		when Memref; Indirection[[arg.base.to_s.to_sym, :+, arg.offset], @size/8, di.address]
+		when Reg; arg.to_s.to_sym
+		else arg
+		end]]
+	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 = Reg.i_to_s.values if wantregs.empty?
+		wantregs.map { |r| r.to_sym }.each(&bt_val)
+
+		puts "update_func_bind: #{Expression[faddr]} has sp -> #{b[:$sp]}" if not Expression[b[:$sp], :-, :$sp].reduce.kind_of?(::Integer) if $VERBOSE
+	end
+
+	def backtrace_is_function_return(expr, di=nil)
+		expr.reduce_rec == :$ra
+	end
+
+	def backtrace_is_stack_address(expr)
+		Expression[expr].expr_externals.include? :$sp
+	end
+
+	def replace_instr_arg_immediate(i, old, new)
+		i.args.map! { |a|
+			case a
+			when Expression; a == old ? new : Expression[a.bind(old => new).reduce]
+			when Memref
+				a.offset = (a.offset == old ? new : Expression[a.offset.bind(old => new).reduce]) if a.offset
+				a
+			else a
+			end
+		}
+	end
+
+	# make the target of the call know the value of $t9 (specified by the ABI)
+	# XXX hackish
+	def backtrace_found_result(dasm, di, expr, type, len)
+		if di.opcode.name == 'jalr' and di.instruction.args == [:$t9]
+			expr = dasm.normalize(expr)
+			(dasm.address_binding[expr] ||= {})[:$t9] ||= expr
+		end
+	end
+
+	def delay_slot(di=nil)
+		# branch.*likely has no delay slot
+		# bltzal/bgezal are 'link', not 'likely', hence the check for -2
+		(di and di.opcode.props[:setip] and (di.opcode.name[-1] != ?l or di.opcode.name[-2] == ?a)) ? 1 : 0
+	end
+
+	def disassembler_default_func
+		df = DecodedFunction.new
+		df.backtrace_binding = %w[v0 v1 a0 a1 a2 a3 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 at k0 k1].inject({}) { |h, r| h.update "$#{r}".to_sym => Expression::Unknown }
+		df.backtrace_binding.update %w[gp sp fp ra s0 s1 s2 s3 s4 s5 s6 s7].inject({}) { |h, r| h.update "$#{r}".to_sym => "$#{r}".to_sym }
+		df.backtracked_for = [BacktraceTrace.new(Expression[:$ra], :default, Expression[:$ra], :x)]
+		df.btfor_callback = lambda { |dasm, btfor, funcaddr, calladdr|
+			if funcaddr != :default
+				btfor
+			elsif di = dasm.decoded[calladdr] and di.opcode.props[:saveip] and di.instruction.to_s != 'jr $ra'
+				btfor
+			else []
+			end
+		}
+		df
+	end
+end
+end

data/lib/metasm/mips/encode.rb

@@ -0,0 +1,51 @@
+#    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/mips/opcodes'
+require 'metasm/encode'
+
+module Metasm
+class MIPS
+	private
+	def encode_instr_op(exe, instr, op)
+		base = op.bin
+		set_field = lambda { |f, v|
+			base |= (v & @fields_mask[f]) << @fields_shift[f]
+		}
+
+		val, mask, shift = 0, 0, 0
+
+		# convert label name for jmp/call/loop to relative offset
+		if op.props[:setip] and op.name[0] != ?t and instr.args.last.kind_of? Expression
+			postlabel = exe.new_label('jmp_offset')
+			instr = instr.dup
+			if op.args.include? :i26
+				pl = Expression[postlabel, :&, 0xfc00_0000]
+			else
+				pl = postlabel
+			end
+			instr.args[-1] = Expression[[instr.args[-1], :-, pl], :>>, 2]
+			postdata = EncodedData.new '', :export => {postlabel => 0}
+		else
+			postdata = ''
+		end
+
+		op.args.zip(instr.args).each { |sym, arg|
+			case sym
+			when :rs, :rt, :rd, :ft
+				set_field[sym, arg.i]
+			when :rs_i16
+				set_field[:rs, arg.base.i]
+				val, mask, shift = arg.offset, @fields_mask[:i16], @fields_shift[:i16]
+			when :sa, :i16, :i20, :i26
+				val, mask, shift = arg, @fields_mask[sym], @fields_shift[sym]
+			end
+		}
+
+		Expression[base, :+, [[val, :&, mask], :<<, shift]].encode(:u32, @endianness) << postdata
+	end
+end
+end

data/lib/metasm/mips/main.rb

@@ -0,0 +1,72 @@
+#    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/main'
+
+module Metasm
+class MIPS < CPU
+	class Reg
+		class << self
+			attr_accessor :s_to_i, :i_to_s
+		end
+		@s_to_i = {}
+		@i_to_s = {}
+		(0..31).each { |i| @s_to_i["r#{i}"] = @s_to_i["$r#{i}"] = @s_to_i["$#{i}"] = i }
+		%w[zero at v0 v1 a0 a1 a2 a3
+		     t0 t1 t2 t3 t4 t5 t6 t7
+		     s0 s1 s2 s3 s4 s5 s6 s7
+		     t8 t9 k0 k1 gp sp fp ra].each_with_index { |r, i| @s_to_i[r] = @s_to_i['$'+r] = i ; @i_to_s[i] = '$'+r }
+
+		attr_accessor :i
+		def initialize(i)
+			@i = i
+		end
+
+		Sym = @i_to_s.sort.map { |k, v| v.to_sym }
+		def symbolic ; @i == 0 ? 0 : Sym[@i] end
+	end
+
+	class FpReg
+		class << self
+			attr_accessor :s_to_i, :i_to_s
+		end
+		@i_to_s = (0..31).map { |i| "$f#{i}" }
+		@s_to_i = (0..31).inject({}) { |h, i| h.update "f#{i}" => i, "$f#{i}" => i }
+
+		attr_accessor :i
+		def initialize(i)
+			@i = i
+		end
+	end
+
+	class Memref
+		attr_accessor :base, :offset
+		def initialize(base, offset)
+			@base, @offset = base, offset
+		end
+
+		def symbolic(orig)
+			p = nil
+			p = Expression[p, :+, @base.symbolic] if base
+			p = Expression[p, :+, @offset] if offset
+			Indirection[p.reduce, 4, orig]
+		end
+	end
+
+	def initialize(endianness = :big, family = :latest)
+		super()
+		@endianness = endianness
+		@size = 32
+		@family = family
+	end
+
+	def init_opcode_list
+		send("init_#@family")
+		@opcode_list
+	end
+end
+end
+

data/lib/metasm/mips/opcodes.rb

@@ -0,0 +1,443 @@
+#    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/mips/main'
+
+# TODO coprocessors, floating point, 64bits, thumb mode
+
+module Metasm
+
+class MIPS
+	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 }
+		@opcode_list << o
+	end
+
+	def init_mips32_obsolete
+		addop 'beql', 0b010100 << 26, :rt,   :rs, :i16, :setip	# == , exec delay slot only if jump taken
+		addop 'bnel', 0b010101 << 26, :rt,   :rs, :i16, :setip	# !=
+		addop 'blezl',0b010110 << 26, :rt_z, :rs, :i16, :setip	# <= 0
+		addop 'bgtzl',0b010111 << 26, :rt_z, :rs, :i16, :setip	# > 0
+		addop 'bltzl',1 << 26 | 0b00010 << 16, :rs, :i16, :setip
+		addop 'bgezl',1 << 26 | 0b00011 << 16, :rs, :i16, :setip
+		addop 'bltzall', 1 << 26 | 0b10010 << 16, :rs, :i16, :setip
+		addop 'bgezall', 1 << 26 | 0b10011 << 16, :rs, :i16, :setip
+	end
+
+	def init_mips32_reserved
+		addop 'future111011', 0b111011 << 26, :i26
+
+		%w[011000 011001 011010 011011  100111 101100 101101 110100 110111 111100 111111].each { |b|
+			addop "reserved#{b}", b.to_i(2) << 26, :i26
+		}
+
+		addop 'ase_jalx', 0b011101 << 26, :i26
+		addop 'ase011110', 0b011110 << 26, :i26
+		# TODO add all special/regimm/...
+	end
+
+	def init_mips32
+		@opcode_list = []
+		@fields_mask.update :rs => 0x1f, :rt => 0x1f, :rd => 0x1f, :sa => 0x1f,
+			:i16 => 0xffff, :i26 => 0x3ffffff, :rs_i16 => 0x3e0ffff, :it => 0x1f,
+			:ft => 0x1f, :idm1 => 0x1f, :idb => 0x1f, :sel => 7, :i20 => 0xfffff #, :i32 => 0
+		@fields_shift.update :rs => 21, :rt => 16, :rd => 11, :sa => 6,
+			:i16 => 0, :i26 => 0, :rs_i16 => 0, :it => 16,
+			:ft => 16, :idm1 => 11, :idb => 11, :sel => 0, :i20 => 6 #, :i32 => 0
+
+		init_mips32_obsolete
+		init_mips32_reserved
+
+		addop 'j',    0b000010 << 26, :i26, :setip, :stopexec	# sets the program counter to (i26 << 2) | ((pc+4) & 0xfc000000) ie i26*4 in the 256M-aligned section containing the instruction in the delay slot
+		addop 'jal',  0b000011 << 26, :i26, :setip, :stopexec, :saveip	# same thing, saves return addr in r31
+
+		addop 'mov',  0b001000 << 26, :rt, :rs			# rt <- rs+0
+		addop 'addi', 0b001000 << 26, :rt, :rs, :i16		# add		rt <- rs+i
+		addop 'li',   0b001001 << 26, :rt, :i16			# add $0	# XXX liu ?
+		addop 'addiu',0b001001 << 26, :rt, :rs, :i16		# add unsigned
+		addop 'slti', 0b001010 << 26, :rt, :rs, :i16		# set on less than
+		addop 'sltiu',0b001011 << 26, :rt, :rs, :i16		# set on less than unsigned
+		addop 'andi', 0b001100 << 26, :rt, :rs, :i16		# and
+		addop 'li',   0b001101 << 26, :rt, :i16			# or $0
+		addop 'ori',  0b001101 << 26, :rt, :rs, :i16		# or
+		addop 'xori', 0b001110 << 26, :rt, :rs, :i16		# xor
+		addop 'lui',  0b001111 << 26, :rt, :i16			# load upper
+#		addop 'li',   (0b001111 << 26) << 32 | (0b001101 << 26), :rt_64, :i32			# lui + ori
+
+		addop 'b',    0b000100 << 26, :i16, :setip, :stopexec	# bz $zero
+		addop 'bz',   0b000100 << 26, :rs, :i16, :setip		# == 0	(beq $0)
+		addop 'bz',   0b000100 << 26, :rt, :i16, :setip		# == 0
+		addop 'bnz',  0b000101 << 26, :rs, :i16, :setip		# != 0
+		addop 'bnz',  0b000101 << 26, :rt, :i16, :setip		# != 0
+
+		addop 'beq',  0b000100 << 26, :rt, :rs, :i16, :setip	# ==
+		addop 'bne',  0b000101 << 26, :rt, :rs, :i16, :setip	# !=
+		addop 'blez', 0b000110 << 26, :rs, :i16, :setip		# <= 0
+		addop 'bgtz', 0b000111 << 26, :rs, :i16, :setip		# > 0
+
+		addop 'lb',   0b100000 << 26, :rt, :rs_i16		# load byte	rs <- [rt+i]
+		addop 'lh',   0b100001 << 26, :rt, :rs_i16		# load halfword
+		addop 'lwl',  0b100010 << 26, :rt, :rs_i16		# load word left
+		addop 'lw',   0b100011 << 26, :rt, :rs_i16		# load word
+		addop 'lbu',  0b100100 << 26, :rt, :rs_i16		# load byte unsigned
+		addop 'lhu',  0b100101 << 26, :rt, :rs_i16		# load halfword unsigned
+		addop 'lwr',  0b100110 << 26, :rt, :rs_i16		# load word right
+
+		addop 'sb',   0b101000 << 26, :rt, :rs_i16		# store byte
+		addop 'sh',   0b101001 << 26, :rt, :rs_i16		# store halfword
+		addop 'swl',  0b101010 << 26, :rt, :rs_i16		# store word left
+		addop 'sw',   0b101011 << 26, :rt, :rs_i16		# store word
+		addop 'swr',  0b101110 << 26, :rt, :rs_i16		# store word right
+
+		addop 'll',   0b110000 << 26, :rt, :rs_i16		# load linked word (read for atomic r/modify/w, sc does the w)
+		addop 'sc',   0b111000 << 26, :rt, :rs_i16		# store conditional word
+
+		addop 'lwc1', 0b110001 << 26, :ft, :rs_i16		# load word in fpreg low
+		addop 'swc1', 0b111001 << 26, :ft, :rs_i16		# store low fpreg word
+		addop 'lwc2', 0b110010 << 26, :rt, :rs_i16		# load word to copro2 register low
+		addop 'swc2', 0b111010 << 26, :rt, :rs_i16		# store low coproc2 register
+
+		addop 'ldc1', 0b110101 << 26, :ft, :rs_i16		# load dword in fpreg low
+		addop 'sdc1', 0b111101 << 26, :ft, :rs_i16		# store fpreg
+		addop 'ldc2', 0b110110 << 26, :rt, :rs_i16		# load dword to copro2 register
+		addop 'sdc2', 0b111110 << 26, :rt, :rs_i16		# store coproc2 register
+
+		addop 'pref', 0b110011 << 26, :it, :rs_i16		# prefetch (it = %w[load store r2 r3 load_streamed store_streamed load_retained store_retained
+									# r8 r9 r10 r11 r12 r13 r14 r15 r16 r17 r18 r19 r20 r21 r22 r23 r24 writeback_invalidate
+									# id26 id27 id28 id29 prepare_for_store id31]
+		addop 'cache',0b101111 << 26, :it, :rs_i16		# do things with the proc cache
+
+		# special
+		addop 'nop',  0
+		addop 'ssnop',1<<6
+		addop 'ehb',  3<<6
+		addop 'sll',  0b000000, :rd, :rt, :sa
+		addop 'movf', 0b000001, :rd, :rs, :cc
+		addop 'movt', 0b000001 | (1<<16), :rd, :rs, :cc
+		addop 'srl',  0b000010, :rd, :rt, :sa
+		addop 'sra',  0b000011, :rd, :rt, :sa
+		addop 'sllv', 0b000100, :rd, :rt, :rs
+		addop 'srlv', 0b000110, :rd, :rt, :rs
+		addop 'srav', 0b000111, :rd, :rt, :rs
+
+		addop 'jr',   0b001000, :rs, :setip, :stopexec			# hint field ?
+		addop 'jr.hb',0b001000 | (1<<10), :rs, :setip, :stopexec
+		addop 'jalr', 0b001001 | (31<<11), :rs, :setip, :stopexec, :saveip	# rd = r31 implicit
+		addop 'jalr', 0b001001, :rd, :rs, :setip, :stopexec, :saveip
+		addop 'jalr.hb', 0b001001 | (1<<10) | (31<<11), :rs, :setip, :stopexec, :saveip
+		addop 'jalr.hb', 0b001001 | (1<<10), :rd, :rs, :setip, :stopexec, :saveip
+		addop 'movz', 0b001010, :rd, :rs, :rt			# rt == 0 ? rd <- rs
+		addop 'movn', 0b001011, :rd, :rs, :rt
+		addop 'syscall', 0b001100, :i20
+		addop 'break',0b001101, :i20, :stopexec
+		addop 'sync', 0b001111					# type 0 implicit
+		addop 'sync', 0b001111, :sa
+
+		addop 'mfhi', 0b010000, :rd				# copies special reg HI to reg
+		addop 'mthi', 0b010001, :rs				# copies reg to special reg HI
+		addop 'mflo', 0b010010, :rd				# copies special reg LO to reg
+		addop 'mtlo', 0b010011, :rs				# copies reg to special reg LO
+
+		addop 'mult', 0b011000, :rs, :rt			# multiplies the registers and store the result in HI:LO
+		addop 'multu',0b011001, :rs, :rt
+		addop 'div',  0b011010, :rs, :rt
+		addop 'divu', 0b011011, :rs, :rt
+		addop 'add',  0b100000, :rd, :rs, :rt
+		addop 'addu', 0b100001, :rd, :rs, :rt
+		addop 'sub',  0b100010, :rd, :rs, :rt
+		addop 'subu', 0b100011, :rd, :rs, :rt
+		addop 'and',  0b100100, :rd, :rs, :rt
+		addop 'or',   0b100101, :rd, :rs, :rt
+		addop 'xor',  0b100110, :rd, :rs, :rt
+		addop 'not',  0b100111, :rd, :rt			# nor $0
+		addop 'not',  0b100111, :rd, :rs
+		addop 'nor',  0b100111, :rd, :rs, :rt
+
+		addop 'slt',  0b101010, :rd, :rs, :rt			# rs<rt ? rd<-1 : rd<-0
+		addop 'sltu', 0b101011, :rd, :rs, :rt
+
+		addop 'tge',  0b110000, :rs, :rt			# rs >= rt ? trap
+		addop 'tgeu', 0b110001, :rs, :rt
+		addop 'tlt',  0b110010, :rs, :rt
+		addop 'tltu', 0b110011, :rs, :rt
+		addop 'teq',  0b110100, :rs, :rt
+		addop 'tne',  0b110110, :rs, :rt
+
+
+		# regimm
+		addop 'bltz', (1<<26) | (0b00000<<16), :rs, :i16, :setip
+		addop 'bgez', (1<<26) | (0b00001<<16), :rs, :i16, :setip
+		addop 'tgei', (1<<26) | (0b01000<<16), :rs, :i16, :setip
+		addop 'tgfiu',(1<<26) | (0b01001<<16), :rs, :i16, :setip
+		addop 'tlti', (1<<26) | (0b01010<<16), :rs, :i16, :setip
+		addop 'tltiu',(1<<26) | (0b01011<<16), :rs, :i16, :setip
+		addop 'teqi', (1<<26) | (0b01100<<16), :rs, :i16, :setip
+		addop 'tnei', (1<<26) | (0b01110<<16), :rs, :i16, :setip
+		addop 'bltzal', (1<<26) | (0b10000<<16), :rs, :i16, :setip, :saveip
+		addop 'bgezal', (1<<26) | (0b10001<<16), :i16, :setip, :stopexec, :saveip	# bgezal $zero => unconditionnal
+		addop 'bgezal', (1<<26) | (0b10001<<16), :rs, :i16, :setip, :saveip
+
+
+		# special2
+		addop 'madd', (0b011100<<26) | 0b000000, :rs, :rt
+		addop 'maddu',(0b011100<<26) | 0b000001, :rs, :rt
+		addop 'mul',  (0b011100<<26) | 0b000010, :rd, :rs, :rt
+		addop 'msub', (0b011100<<26) | 0b000100, :rs, :rt
+		addop 'msubu',(0b011100<<26) | 0b000101, :rs, :rt
+		addop 'clz',  (0b011100<<26) | 0b100000, :rd, :rs, :rt	# must have rs == rt
+		addop 'clo',  (0b011100<<26) | 0b100001, :rd, :rs, :rt	# must have rs == rt
+		addop 'sdbbp',(0b011100<<26) | 0b111111, :i20
+
+
+		# cp0
+		addop 'mfc0', (0b010000<<26) | (0b00000<<21), :rt, :rd
+		addop 'mfc0', (0b010000<<26) | (0b00000<<21), :rt, :rd, :sel
+		addop 'mtc0', (0b010000<<26) | (0b00100<<21), :rt, :rd
+		addop 'mtc0', (0b010000<<26) | (0b00100<<21), :rt, :rd, :sel
+
+		addop 'tlbr', (0b010000<<26) | (1<<25) | 0b000001
+		addop 'tlbwi',(0b010000<<26) | (1<<25) | 0b000010
+		addop 'tlbwr',(0b010000<<26) | (1<<25) | 0b000110
+		addop 'tlbp', (0b010000<<26) | (1<<25) | 0b001000
+		addop 'eret', (0b010000<<26) | (1<<25) | 0b011000
+		addop 'deret',(0b010000<<26) | (1<<25) | 0b011111
+		addop 'wait', (0b010000<<26) | (1<<25) | 0b100000	# mode field ?
+	end
+
+	def init_mips32r2
+		init_mips32
+
+		addop 'rotr', 0b000010 | (1<<21), :rd, :rt, :sa
+		addop 'rotrv',0b000110 | (1<<6), :rd, :rt, :rs
+
+		addop 'synci',(1<<26) | (0b11111<<16), :rs_i16
+
+		# special3
+		addop 'ext', (0b011111<<26) | 0b000000, :rt, :rs, :sa, :idm1
+		addop 'ins', (0b011111<<26) | 0b000100, :rt, :rs, :sa, :idb
+		addop 'rdhwr',(0b011111<<26)| 0b111011, :rt, :rd
+		addop 'wsbh',(0b011111<<26) | (0b00010<<6) | 0b100000, :rd, :rt
+		addop 'seb', (0b011111<<26) | (0b10000<<6) | 0b100000, :rd, :rt
+		addop 'seh', (0b011111<<26) | (0b11000<<6) | 0b100000, :rd, :rt
+
+		# cp0
+		addop 'rdpgpr', (0b010000<<26) | (0b01010<<21), :rd, :rt
+		addop 'wrpgpr', (0b010000<<26) | (0b01110<<21), :rd, :rt
+		addop 'di',     (0b010000<<26) | (0b01011<<21) | (0b01100<<11) | (0<<5)
+		addop 'di',     (0b010000<<26) | (0b01011<<21) | (0b01100<<11) | (0<<5), :rt
+		addop 'ei',     (0b010000<<26) | (0b01011<<21) | (0b01100<<11) | (1<<5)
+		addop 'ei',     (0b010000<<26) | (0b01011<<21) | (0b01100<<11) | (1<<5), :rt
+	end
+	alias init_latest init_mips32r2
+end
+end
+__END__
+	def macro_addop_cop1(name, bin, *aprops)
+		flds = [ :rt, :fs ]
+		addop name, :cop1, bin, 'rt, fs', flds, *aprops
+	end
+
+	def macro_addop_cop1_precision(name, type, bin, fmt, *aprops)
+		flds = [ :ft, :fs, :fd ]
+		addop name+'.'+(type.to_s[5,7]), type, bin, fmt, flds, *aprops
+	end
+
+
+	public
+	# Initialize the instruction set with the MIPS32 Instruction Set
+	def init_mips32
+					:cc => [7, 18, :fpcc],
+					:op => [0x1F, 16, :op ], :cp2_rt => [0x1F, 16, :cp2_reg ],
+					:stype => [0x1F, 6, :imm ],
+					:code => [0xFFFFF, 6, :code ],
+					:sel => [3, 0, :sel ]})
+
+		# ---------------------------------------------------------------
+		# COP0, field rs
+		# ---------------------------------------------------------------
+
+		addop 'mfc0', :cop0, 0b00000, 'rt, rd, sel', [ :rt, :rd, :sel ]
+		addop 'mtc0', :cop0, 0b00100, 'rt, rd, sel', [ :rt, :rd, :sel ]
+
+		# ---------------------------------------------------------------
+		# COP0 when rs=C0
+		# ---------------------------------------------------------------
+
+		macro_addop_cop0_c0 'tlbr',  0b000001
+		macro_addop_cop0_c0 'tlbwi', 0b000010
+		macro_addop_cop0_c0 'tlwr',  0b000110
+		macro_addop_cop0_c0 'tlbp',  0b001000
+		macro_addop_cop0_c0 'eret',  0b011000
+		macro_addop_cop0_c0 'deret', 0b011111
+		macro_addop_cop0_c0 'wait',  0b100000
+
+		# ---------------------------------------------------------------
+		# COP1, field rs
+		# ---------------------------------------------------------------
+
+		macro_addop_cop1 'mfc1', 0b00000
+		macro_addop_cop1 'cfc1', 0b00010
+		macro_addop_cop1 'mtc1', 0b00100
+		macro_addop_cop1 'ctc1', 0b00110
+
+		addop "bc1f",  :cop1, 0b01000, 'cc, off', [ :cc, :off ], :diff_bits, [ 16, 3, 0 ]
+		addop "bc1fl", :cop1, 0b01000, 'cc, off', [ :cc, :off ], :diff_bits, [ 16, 3, 2 ]
+		addop "bc1t",  :cop1, 0b01000, 'cc, off', [ :cc, :off ], :diff_bits, [ 16, 3, 1 ]
+		addop "bc1tl", :cop1, 0b01000, 'cc, off', [ :cc, :off ], :diff_bits, [ 16, 3, 3 ]
+
+		# ---------------------------------------------------------------
+		# COP1, field rs=S/D
+		# ---------------------------------------------------------------
+
+		[ :cop1_s, :cop1_d ].each do |type|
+		type_str = type.to_s[5,7]
+
+		macro_addop_cop1_precision 'add',  type, 0b000000, 'fd, fs, ft'
+		macro_addop_cop1_precision 'sub',  type, 0b000001, 'fd, fs, ft'
+		macro_addop_cop1_precision 'mul',  type, 0b000010, 'fd, fs, ft'
+		macro_addop_cop1_precision 'abs',  type, 0b000101, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'mov',  type, 0b000110, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'neg',  type, 0b000111, 'fd, fs', :ft_zero
+
+		macro_addop_cop1_precision 'movz', type, 0b010010, 'fd, fs, ft'
+		macro_addop_cop1_precision 'movn', type, 0b010011, 'fd, fs, ft'
+
+		addop "movf.#{type_str}", type, 0b010001, 'fd, fs, cc', [ :cc, :fs, :fd ], :diff_bits, [ 16, 1, 0 ]
+		addop "movt.#{type_str}", type, 0b010001, 'fd, fs, cc', [ :cc, :fs, :fd ], :diff_bits, [ 16, 1, 1 ]
+
+		%w(f un eq ueq olt ult ole ule sf ngle seq ngl lt nge le ngt).each_with_index do |cond, index|
+			addop "c.#{cond}.#{type_str}", type, 0b110000+index, 'cc, fs, ft',
+			[ :ft, :fs, :cc ]
+		end
+		end
+
+		# S and D Without PS
+
+		[:cop1_s, :cop1_d].each do |type|
+		macro_addop_cop1_precision 'div',  type, 0b000011, 'fd, fs, ft'
+		macro_addop_cop1_precision 'sqrt', type, 0b000100, 'fd, fs', :ft_zero
+
+		macro_addop_cop1_precision 'round.w', type, 0b001100, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'trunc.w', type, 0b001101, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'ceil.w',  type, 0b001110, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'floor.w', type, 0b001111, 'fd, fs', :ft_zero
+
+		end
+
+		# COP2 is not decoded (pretty useless)
+
+		[:cop1_d,:cop1_w].each { |type| macro_addop_cop1_precision 'cvt.s', type, 0b100000, 'fd, fs', :ft_zero }
+		[:cop1_s,:cop1_w].each { |type| macro_addop_cop1_precision 'cvt.d', type, 0b100001, 'fd, fs', :ft_zero }
+		[:cop1_s,:cop1_d].each { |type| macro_addop_cop1_precision 'cvt.w', type, 0b100100, 'fd, fs', :ft_zero }
+
+		[ :normal, :special, :regimm, :special2, :cop0, :cop0_c0, :cop1, :cop1_s,
+		  :cop1_d, :cop1_w ].each \
+			{ |t| @@opcodes_by_class[t] = opcode_list.find_all { |o| o.type == t } }
+	end
+
+	# Initialize the instruction set with the MIPS32 Instruction Set Release 2
+	def init_mips64
+		init_mips32
+
+		#SPECIAL
+		macro_addop_special "rotr",  0b000010, 'rd, rt, sa', :diff_bits, [ 26, 1, 1 ]
+		macro_addop_special "rotrv", 0b000110, 'rd, rt, rs', :diff_bits, [ 6, 1, 1 ]
+
+		# REGIMM
+		addop "synci", :regimm, 0b11111, '', {:base => [5,21], :off => [16, 0] }
+
+		# ---------------------------------------------------------------
+		# SPECIAL3 opcode encoding of function field
+		# ---------------------------------------------------------------
+
+		addop "ext", :special3, 0b00000, 'rt, rs, pos, size', { :rs => [5, 21], :rt => [5, 16],
+									:msbd => [5, 11], :lsb => [5, 6] }
+		addop "ins", :special3, 0b00100, 'rt, rs, pos, size', { :rs => [5, 21], :rt => [5, 16],
+									:msb => [5, 11], :lsb => [5, 6] }
+
+		addop "rdhwr", :special3, 0b111011, 'rt, rd', { :rt => [5, 16], :rd => [5, 11] }
+
+		addop "wsbh", :bshfl, 0b00010, 'rd, rt', { :rt => [5, 16], :rd => [5, 11] }
+		addop "seb",  :bshfl, 0b10000, 'rd, rt', { :rt => [5, 16], :rd => [5, 11] }
+		addop "seh",  :bshfl, 0b11000, 'rd, rt', { :rt => [5, 16], :rd => [5, 11] }
+
+		# ---------------------------------------------------------------
+		# COP0
+		# ---------------------------------------------------------------
+
+		addop "rdpgpr", :cop0, 0b01010, 'rt, rd', {:rt => [5, 16], :rd => [5, 11] }
+		addop "wdpgpr", :cop0, 0b01110, 'rt, rd', {:rt => [5, 16], :rd => [5, 11] }
+		addop "di",     :cop0, 0b01011, '', {}, :diff_bits, [ 5, 1 , 0]
+		addop "ei",     :cop0, 0b01011, '', {}, :diff_bits, [ 5, 1 , 1]
+
+		# ---------------------------------------------------------------
+		# COP1, field rs
+		# ---------------------------------------------------------------
+
+		macro_addop_cop1 "mfhc1", 0b00011
+		macro_addop_cop1 "mthc1", 0b00111
+
+		# Floating point
+
+		[:cop1_s, :cop1_d].each do |type|
+		macro_addop_cop1_precision 'round.l', type, 0b001000, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'trunc.l', type, 0b001001, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'ceil.l',  type, 0b001010, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'floor.l', type, 0b001011, 'fd, fs', :ft_zero
+
+		macro_addop_cop1_precision 'recip', type, 0b010101, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'rsqrt', type, 0b010110, 'fd, fs', :ft_zero
+
+		macro_addop_cop1_precision 'cvt.l', type, 0b100101, 'fd, fs', :ft_zero
+		end
+		macro_addop_cop1_precision 'cvt.ps', :cop1_s, 0b100110, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'cvt.s', :cop1_l, 0b100000, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'cvt.d', :cop1_l, 0b100000, 'fd, fs', :ft_zero
+
+		macro_addop_cop1_precision 'add',  :cop1_ps, 0b000000, 'fd, fs, ft'
+		macro_addop_cop1_precision 'sub',  :cop1_ps, 0b000001, 'fd, fs, ft'
+		macro_addop_cop1_precision 'mul',  :cop1_ps, 0b000010, 'fd, fs, ft'
+		macro_addop_cop1_precision 'abs',  :cop1_ps, 0b000101, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'mov',  :cop1_ps, 0b000110, 'fd, fs', :ft_zero
+		macro_addop_cop1_precision 'neg',  :cop1_ps, 0b000111, 'fd, fs', :ft_zero
+
+		macro_addop_cop1_precision 'movz', :cop1_ps, 0b010010, 'fd, fs, ft'
+		macro_addop_cop1_precision 'movn', :cop1_ps, 0b010011, 'fd, fs, ft'
+
+		addop "movf.#{:cop1_ps_str}", :cop1_ps, 0b010001, 'fd, fs, cc', [ :cc, :fs, :fd ]
+		addop "movt.#{:cop1_ps_str}", :cop1_ps, 0b010001, 'fd, fs, cc', [ :cc, :fs, :fd ]
+
+		%w(f un eq ueq olt ult ole ule sf ngle seq ngl lt nge le ngt).each_with_index do |cond, index|
+			addop "c.#{cond}.ps", :cop1_cond, 0b110000+index, 'cc, fs, ft',
+			[ :ft, :fs, :cc ]
+
+		# TODO: COP1X
+
+		[ :special3, :bshfl, :cop1_l, :cop1_ps ].each \
+			{ |t| @@opcodes_by_class[t] = opcode_list.find_all { |o| o.type == t } }
+	end
+
+	end
+
+	# Reset all instructions
+	def reset
+		metaprops_allowed.clear
+		args_allowed.clear
+		props_allowed.clear
+		fields_spec.clear
+		opcode_list.clear
+	end
+
+end
+	# Array containing all the supported opcodes
+	attr_accessor :opcode_list
+
+	init_mips32
+end
+
+end