metasm 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67b43e2e4f4fb324ee2ea574e15cb2eec4ed1215
-  data.tar.gz: 4b9dcff449fe4ec812e03c52ab8cc2611f05ad46
+  metadata.gz: 8a5dcb50d2a38105adee7c8249698e2f675af544
+  data.tar.gz: 0476236904d2bc2b8d45013446a58d053f0f24aa
 SHA512:
-  metadata.gz: 1b14f7f6c2f68761a258ecb40e4b59f29f968a128d2560c59cf40a81cb30a8a9e1f16c4b89a6ccf674fdd203083c443d883dbfbdec54a687f6db9af2817a1954
-  data.tar.gz: 2724ae05df0770e22d1c11d8d00b15ca911df0d89d21b12858d219ce9974d45b1fe4b34b3f1d5d8614a4fda699d424a7c11c3c02ee21435803f03b079c7d7d24
+  metadata.gz: ad41d74f97fab2567509acddb90ea7124c317519e84af509c6e68d07839ff1015a2c4512286e76eb16db22efa481aa60531beeb66e5ec9c0677727ba6cf81571
+  data.tar.gz: 333a45fd258674ead5f2b036e56e8e87ad06b4aa74b5f655495d05b902394527dad0abf78e614c7d6f715caa3d92c05b322166bfed74fb611ad3ddabbd4f7a1c

data/.gitignore

@@ -1 +1,3 @@
 pkg/**
+doc/**/*.html
+metasm/dynldr-*.so

data/Gemfile

@@ -1 +1,2 @@
+source 'https://rubygems.org'
 gemspec

data/doc/code_organisation.txt

@@ -107,7 +107,7 @@ The actual implementation of the GUI are found in:
 
 Please note that the Qt backend does not work *at all*.
 
-The `gui.rb` file in the main directory is used to chose among the available GUI backend
+The `gui.rb` file in the main directory is used to choose among the available GUI backend
 the most appropriate for the current session.
 
 

data/metasm.gemspec

@@ -4,7 +4,7 @@ require 'metasm'
 
 Gem::Specification.new do |s|
   s.name          = 'metasm'
-  s.version       = '1.0.2'
+  s.version       = '1.0.3'
   s.summary       =
     "Metasm is a cross-architecture assembler, disassembler, linker, and debugger."
   s.description   = ""

data/metasm.rb

@@ -16,6 +16,7 @@ module Metasm
 		'X86' => 'Ia32', 'PPC' => 'PowerPC',
 		'X64' => 'X86_64', 'AMD64' => 'X86_64',
 		'MIPS64' => 'MIPS', 'AArch64' => 'ARM64',
+		'TransPuter' => 'ST20',
 		'UniversalBinary' => 'MachO', 'COFFArchive' => 'COFF',
 		'DEY' => 'DEX',
 		'PTrace' => 'LinOS', 'FatELF' => 'ELF',
@@ -36,7 +37,7 @@ module Metasm
 		'Ia32' => 'cpu/ia32', 'MIPS' => 'cpu/mips', 'PowerPC' => 'cpu/ppc', 'ARM' => 'cpu/arm',
 		'X86_64' => 'cpu/x86_64', 'Sh4' => 'cpu/sh4', 'Dalvik' => 'cpu/dalvik', 'ARC' => 'cpu/arc',
 		'Python' => 'cpu/python', 'Z80' => 'cpu/z80', 'CY16' => 'cpu/cy16', 'BPF' => 'cpu/bpf',
-		'MSP430' => 'cpu/msp430', 'ARM64' => 'cpu/arm64',
+		'MSP430' => 'cpu/msp430', 'ARM64' => 'cpu/arm64', 'ST20' => 'cpu/st20', 'MCS51' => 'cpu/mcs51',
 		'C' => 'compile_c',
 		'MZ' => 'exe_format/mz', 'PE' => 'exe_format/pe',
 		'ELF' => 'exe_format/elf', 'COFF' => 'exe_format/coff',

data/metasm/cpu/arc/decode.rb

@@ -79,7 +79,7 @@ class ARC
 		lookaside = lookaside[sub_opcode(val)] if @instrlength == 32 and maj == 5
 
 		op = lookaside.select { |opcode|
-			if $ARC_DEBUG and (val & opcode.bin_mask) == opcode.bin
+			if false and (val & opcode.bin_mask) == opcode.bin
 				puts "#{opcode.bin_mask.to_s(16)} - #{opcode.bin.to_s(16)} - #{(val & opcode.bin_mask).to_s(16)} -  #{opcode.name} - #{opcode.args}"
 			end
 			(val & opcode.bin_mask) == opcode.bin
@@ -255,7 +255,7 @@ class ARC
 					tmp = field_val[a]
 					#c = tmp & 0x3F
 					tmp = tmp >> 6
-					b = (tmp >> 12) | ((tmp & 0x7) << 3)
+					#b = (tmp >> 12) | ((tmp & 0x7) << 3)
 					Memref.new(field_val[:bext],  field_val[:cext], memref_size(di))
 
 				when :u6, :u6e, :s8e, :s9, :s12; Expression[field_val[a]]
@@ -263,7 +263,7 @@ class ARC
 				when :auxs12; AUX.new field_val[:s12]
 				when :@c; Memref.new(GPR.new(field_val[a]),  nil, memref_size(di))
 				when :@bcext; Memref.new(field_val[a],  nil, memref_size(di))
-				when :@bcext; Memref.new(field_val[:b], field_val[:cext], memref_size(di))
+				#when :@bcext; Memref.new(field_val[:b], field_val[:cext], memref_size(di))
 				when :@bs9
 					# [b,s9] or [limm] if b = 0x3E
 					base = field_val[:bext]

data/metasm/cpu/arm/decode.rb

@@ -41,7 +41,7 @@ class ARM
 		return if edata.ptr+4 > edata.length
 		di = DecodedInstruction.new(self)
 		val = edata.decode_imm(:u32, @endianness)
-		di.instance_variable_set('@raw', val)
+		di.misc = val
 		di if di.opcode = @bin_lookaside[(val >> 20) & 0xff].find { |op|
 			(not op.props[:cond] or
 			 ((val >> @fields_shift[:cond]) & @fields_mask[:cond]) != 0xf) and
@@ -57,7 +57,7 @@ class ARM
 	def decode_instr_op(edata, di)
 		op = di.opcode
 		di.instruction.opname = op.name
-		val = di.instance_variable_get('@raw')
+		val = di.misc	# saved decoded u32
 
 		field_val = lambda { |f|
 			r = (val >> @fields_shift[f]) & @fields_mask[f]

data/metasm/cpu/ia32/compile_c.rb

@@ -267,6 +267,11 @@ class CCompiler < C::Compiler
 						e2 = inuse findreg(rsz)
 						op = ((type.specifier == :unsigned) ? 'movzx' : 'movsx')
 						op = 'mov' if e.sz == e2.sz
+					elsif e.sz > sz
+						e2 = inuse findreg(sz)
+						el, eh = get_composite_parts(e)
+						e = el
+						op = 'mov'
 					else
 						e2 = inuse findreg(sz)
 						op = 'mov'
@@ -779,6 +784,9 @@ class CCompiler < C::Compiler
 						else
 							instr 'mov', l, Reg.new(r.val, l.sz)
 						end
+					elsif r.kind_of? Composite
+						rl, rh = get_composite_parts r
+						instr 'mov', l, rl
 					else
 						instr 'mov', l, r
 					end
@@ -1329,11 +1337,11 @@ class CCompiler < C::Compiler
 			unuse l, r
 			if expr.lexpr.type.integral?
 				if expr.lexpr.type.name == :__int64 and @cpusz != 64
-					raise # TODO
+					raise "unsupported 64bit comparison #{expr}"	# TODO
 				end
 				instr 'cmp', l, r
 			elsif expr.lexpr.type.float?
-				raise # TODO
+				raise "unsupported float comparison #{expr}"	# TODO
 				instr 'fcmpp', l, r
 			else raise 'bad comparison ' + expr.to_s
 			end
@@ -1343,12 +1351,20 @@ class CCompiler < C::Compiler
 			r = c_cexpr_inner(expr.rexpr)
 			r = make_volatile(r, expr.rexpr.type)
 			unuse r
+			if r.kind_of? Composite
+				r, rh = get_composite_parts(r)
+				instr 'or', r, rh
+			end
 			instr 'test', r, r
 			instr 'jz', Expression[target]
 		else
 			r = c_cexpr_inner(expr)
 			r = make_volatile(r, expr.type)
 			unuse r
+			if r.kind_of? Composite
+				r, rh = get_composite_parts(r)
+				instr 'or', r, rh
+			end
 			instr 'test', r, r
 			instr 'jnz', Expression[target]
 		end

data/metasm/cpu/ia32/decode.rb

@@ -403,7 +403,12 @@ class Ia32
 					# ror a, b  =>  (a >> b) | (a << (32-b))
 					{ a0 => Expression[[[[a0, :&, operandmask], e_op, sz], :|, [[a0, :&, operandmask], inv_op, isz]], :&, operandmask] }
 				}
-			when 'sar', 'shl', 'sal'; lambda { |di, a0, a1| { a0 => Expression[a0, (op[-1] == ?r ? :>> : :<<), [a1, :%, [opsz(di), 32].max]] } }
+			when 'shl', 'sal'; lambda { |di, a0, a1| { a0 => Expression[a0, (op[-1] == ?r ? :>> : :<<), [a1, :%, [opsz(di), 32].max]] } }
+			when 'sar'; lambda { |di, a0, a1|
+				sz = [opsz(di), 32].max
+				a1 = [a1, :%, sz]
+				{ a0 => Expression[[a0, :>>, a1], :|,
+						   [[[mask[di], :*, sign[a0, di]], :<<, [sz, :-, a1]], :&, mask[di]]] } }
 			when 'shr'; lambda { |di, a0, a1| { a0 => Expression[[a0, :&, mask[di]], :>>, [a1, :%, opsz(di)]] } }
 			when 'shrd'
 				lambda { |di, a0, a1, a2|
@@ -423,7 +428,7 @@ class Ia32
 			when 'pop'
 				lambda { |di, a0| { esp => Expression[esp, :+, opsz(di)/8],
 					a0 => Indirection[esp, opsz(di)/8, di.address] } }
-			when 'pushfd', 'pushf'
+			when 'pushfd', 'pushf', 'pushfq'
 				# TODO Unknown per bit
 				lambda { |di|
 					efl = Expression[0x202]
@@ -434,7 +439,7 @@ class Ia32
 					bts[11, :eflag_o]
 					{ esp => Expression[esp, :-, opsz(di)/8], Indirection[esp, opsz(di)/8, di.address] => efl }
 				}
-			when 'popfd', 'popf'
+			when 'popfd', 'popf', 'popfq'
 				lambda { |di| bt = lambda { |pos| Expression[[Indirection[esp, opsz(di)/8, di.address], :>>, pos], :&, 1] }
 					{ esp => Expression[esp, :+, opsz(di)/8], :eflag_c => bt[0], :eflag_z => bt[6], :eflag_s => bt[7], :eflag_o => bt[11] } }
 			when 'sahf'
@@ -551,7 +556,7 @@ class Ia32
 					op =~ /^(stos|movs|lods|scas|cmps)([bwdq])$/
 					e_op = $1
 					sz = { 'b' => 1, 'w' => 2, 'd' => 4, 'q' => 8 }[$2]
-					eax_ = Reg.new(0, 8*sz).symbolic
+					eax_ = self.class::Reg.new(0, 8*sz).symbolic
 					dir = :+
 					if di.block and (di.block.list.find { |ddi| ddi.opcode.name == 'std' } rescue nil)
 						dir = :-

data/metasm/cpu/ia32/decompile.rb

@@ -11,10 +11,19 @@ class Ia32
 	# temporarily setup dasm.address_binding so that backtracking
 	# stack-related offsets resolve in :frameptr (relative to func start)
 	def decompile_makestackvars(dasm, funcstart, blocks)
+		esp = register_symbols[4]
 		oldfuncbd = dasm.address_binding[funcstart]
-		dasm.address_binding[funcstart] = { :esp => :frameptr }	# this would suffice, the rest here is just optimisation
-
+		dasm.address_binding[funcstart] = { esp => :frameptr }
 		patched_binding = [funcstart]	# list of addresses to cleanup later
+
+		if blocks.length <= 12
+			blocks.each { |block| yield block }
+			return
+		end
+
+		# for large function, pre-trace and cache esp/ebp for every block start to improve decompilation time
+
+		ebp = register_symbols[5]
 		ebp_frame = true
 
 		# pretrace esp and ebp for each function block (cleared later)
@@ -24,16 +33,16 @@ class Ia32
 			if not dasm.address_binding[blockstart]
 				patched_binding << blockstart
 				dasm.address_binding[blockstart] = {}
-				foo = dasm.backtrace(:esp, blockstart, :snapshot_addr => funcstart)
+				foo = dasm.backtrace(esp, blockstart, :snapshot_addr => funcstart)
 				if foo.length == 1 and ee = foo.first and ee.kind_of? Expression and (ee == Expression[:frameptr] or
 						(ee.lexpr == :frameptr and ee.op == :+ and ee.rexpr.kind_of? ::Integer))
-					dasm.address_binding[blockstart][:esp] = ee
+					dasm.address_binding[blockstart][esp] = ee
 				end
 				if ebp_frame
-					foo = dasm.backtrace(:ebp, blockstart, :snapshot_addr => funcstart)
+					foo = dasm.backtrace(ebp, blockstart, :snapshot_addr => funcstart)
 					if foo.length == 1 and ee = foo.first and ee.kind_of? Expression and (ee == Expression[:frameptr] or
 							(ee.lexpr == :frameptr and ee.op == :+ and ee.rexpr.kind_of? ::Integer))
-						dasm.address_binding[blockstart][:ebp] = ee
+						dasm.address_binding[blockstart][ebp] = ee
 					else
 						ebp_frame = false	# func does not use ebp as frame ptr, no need to bt for later blocks
 					end
@@ -48,6 +57,11 @@ class Ia32
 		dasm.address_binding[funcstart] = oldfuncbd if oldfuncbd
 	end
 
+	# add di-specific registry written/accessed
+	def decompile_func_finddeps_di(dcmp, func, di, a, w)
+		a << :eax if di.opcode.name == 'ret' and (not func.type.kind_of? C::BaseType or func.type.type.name != :void)	# standard ABI
+	end
+
 	# list variable dependency for each block, remove useless writes
 	# returns { blockaddr => [list of vars that are needed by a following block] }
 	def decompile_func_finddeps(dcmp, blocks, func)
@@ -69,7 +83,7 @@ class Ia32
 					else a |= Expression[k].externals	# if dword [eax] <- 42, eax is read
 					end
 				}
-				a << :eax if di.opcode.name == 'ret' and (not func.type.kind_of? C::BaseType or func.type.type.name != :void)	# standard ABI
+				decompile_func_finddeps_di(dcmp, func, di, a, w)
 
 				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]
@@ -120,7 +134,7 @@ class Ia32
 						else a |= Expression[k].externals	# if dword [eax] <- 42, eax is read
 						end
 					}
-					a << :eax if di.opcode.name == 'ret' and (not func.type.kind_of? C::BaseType or func.type.type.name != :void)	# standard ABI
+					decompile_func_finddeps_di(dcmp, func, di, a, w)
 
 					next true if (a.map { |ee| Expression[ee].externals.grep(::Symbol) }.flatten - [:unknown] - bw).include? r
 					bw |= w.map { |ee| Expression[ee].externals.grep(::Symbol) }.flatten - [:unknown]

data/metasm/cpu/ia32/opcodes.rb

@@ -475,7 +475,7 @@ class Ia32
 		addop 'pavgb',   [0x0F, 0xE0], :mrmmmx
 		addop 'pavgw',   [0x0F, 0xE3], :mrmmmx
 		addop 'pextrw',  [0x0F, 0xC5, 0xC0], nil, {:reg => [2, 3], :regmmx => [2, 0]}, :reg, :regmmx, :u8
-		addop 'pinsrw',  [0x0F, 0xC4, 0x00], nil, {:modrm => [2, 0], :regmmx => [2, 3]}, :modrm, :regmmx, :u8
+		addop 'pinsrw',  [0x0F, 0xC4, 0x00], nil, {:modrm => [2, 0], :regmmx => [2, 3]}, :regmmx, :modrm, :u8
 		addop 'pmaxsw',  [0x0F, 0xEE], :mrmmmx
 		addop 'pmaxub',  [0x0F, 0xDE], :mrmmmx
 		addop 'pminsw',  [0x0F, 0xEA], :mrmmmx
@@ -644,7 +644,7 @@ class Ia32
 		addop('vmclear',  [0x0F, 0xC7, 6<<3], :modrmA) { |o| o.props[:argsz] = 64 ; o.props[:needpfx] = 0x66 }
 		addop('vmxon',    [0x0F, 0xC7, 6<<3], :modrmA) { |o| o.props[:argsz] = 64 ; o.props[:needpfx] = 0xF3 }
 		addop('vmptrld',  [0x0F, 0xC7, 6<<3], :modrmA) { |o| o.props[:argsz] = 64 }
-		addop('vmptrrst', [0x0F, 0xC7, 7<<3], :modrmA) { |o| o.props[:argsz] = 64 }
+		addop('vmptrst',  [0x0F, 0xC7, 7<<3], :modrmA) { |o| o.props[:argsz] = 64 }
 		addop('invept',   [0x0F, 0x38, 0x80], :mrmA) { |o| o.props[:needpfx] = 0x66 }
 		addop('invvpid',  [0x0F, 0x38, 0x81], :mrmA) { |o| o.props[:needpfx] = 0x66 }
 
@@ -674,9 +674,9 @@ class Ia32
 		addop('pblendvb', [0x0F, 0x38, 0x10], :mrmxmm) { |o| o.props[:needpfx] = 0x66 }
 		addop('pblendw',  [0x0F, 0x3A, 0x1E], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66 }
 		addop('pcmpeqq',  [0x0F, 0x38, 0x29], :mrmxmm) { |o| o.props[:needpfx] = 0x66 }
-		addop('pextrb', [0x0F, 0x3A, 0x14], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66; o.args[o.args.index(:modrmxmm)] = :modrm; o.props[:argsz] = 8 }
-		addop('pextrw', [0x0F, 0x3A, 0x15], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66; o.args[o.args.index(:modrmxmm)] = :modrm; o.props[:argsz] = 16 }
-		addop('pextrd', [0x0F, 0x3A, 0x16], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66; o.args[o.args.index(:modrmxmm)] = :modrm; o.props[:argsz] = 32 }
+		addop('pextrb', [0x0F, 0x3A, 0x14], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66; o.args.index(:modrmxmm); o.args.unshift(:modrm); o.props[:argsz] = 8 }
+		addop('pextrw', [0x0F, 0x3A, 0x15], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66; o.args.index(:modrmxmm); o.args.unshift(:modrm); o.props[:argsz] = 16 }
+		addop('pextrd', [0x0F, 0x3A, 0x16], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66; o.args.index(:modrmxmm); o.args.unshift(:modrm); o.props[:argsz] = 32 }
 		addop('pinsrb', [0x0F, 0x3A, 0x20], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66; o.args[o.args.index(:modrmxmm)] = :modrm; o.props[:argsz] = 8 }
 		addop('pinsrw', [0x0F, 0x3A, 0x21], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66; o.args[o.args.index(:modrmxmm)] = :modrm; o.props[:argsz] = 16 }
 		addop('pinsrd', [0x0F, 0x3A, 0x22], :mrmxmm, :u8) { |o| o.props[:needpfx] = 0x66; o.args[o.args.index(:modrmxmm)] = :modrm; o.props[:argsz] = 32 }

data/metasm/cpu/mcs51.rb

@@ -0,0 +1,8 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2015 Google
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+
+require 'metasm/main'
+require 'metasm/cpu/mcs51/decode'

data/metasm/cpu/mcs51/decode.rb

@@ -0,0 +1,99 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2015-2016 Google
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+
+require 'metasm/cpu/mcs51/opcodes'
+require 'metasm/decode'
+
+module Metasm
+class MCS51
+
+	def build_opcode_bin_mask(op)
+		op.bin_mask = 0
+		op.fields.each { |f, off|
+			op.bin_mask |= (@fields_mask[f] << off)
+		}
+		op.bin_mask ^= 0xff
+	end
+
+	def build_bin_lookaside
+		lookaside = Array.new(256) { [] }
+		opcode_list.each { |op|
+			build_opcode_bin_mask op
+			b   = op.bin
+			msk = op.bin_mask
+			for i in b..(b | (255^msk))
+				lookaside[i] << op if i & msk == b & msk
+			end
+		}
+		lookaside
+	end
+
+	def decode_findopcode(edata)
+		di = DecodedInstruction.new self
+		byte = edata.data[edata.ptr]
+		byte = byte.unpack('C').first if byte.kind_of?(::String)
+		if not byte
+			return
+		end
+		return di if di.opcode = @bin_lookaside[byte].find { |op|
+			byte & op.bin_mask == op.bin & op.bin_mask
+		}
+	end
+
+	def decode_instr_op(edata, di)
+		before_ptr = edata.ptr
+		op = di.opcode
+		di.instruction.opname = op.name
+		bseq = edata.get_byte
+
+		field_val = lambda { |f|
+			if fld = op.fields[f]
+				(bseq >> fld) & @fields_mask[f]
+			end
+		}
+
+		op.args.each { |a|
+			di.instruction.args << case a
+			when :rel8
+				Expression[edata.decode_imm(:i8, @endianness)]
+			when :d8
+				Immediate.new(edata.decode_imm(:u8, @endianness))
+			when :m8
+				Memref.new(nil, edata.decode_imm(:u8, @endianness))
+			when :rd
+				if (field_val[a] & 0b1110) == 0b0110
+					Memref.new(Reg.new(field_val[a] + 2), nil)
+				else
+					Reg.new(field_val[a])
+				end
+			when :r_a
+				Reg.from_str('A')
+			when :r_b
+				Reg.from_str('B')
+			when :r_c
+				Reg.from_str('C')
+			when :addr_11
+				Memref.new(nil, edata.decode_imm(:u8, @endianness))
+			when :addr_16
+				Memref.new(nil, edata.decode_imm(:u16, @endianness))
+			end
+		}
+
+		di.bin_length += edata.ptr - before_ptr
+
+		di
+	end
+
+	def backtrace_binding(b)
+		@backtrace_binding ||= {}
+	end
+
+	def get_xrefs_x(b,c)
+		[]
+	end
+
+end
+end

data/metasm/cpu/mcs51/main.rb

@@ -0,0 +1,76 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2015-2016 Google
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+
+require 'metasm/main'
+
+module Metasm
+class MCS51 < CPU
+
+	class Reg
+		I_TO_S  = { 0x4 => 'A',
+		            0x5 => 'B',
+		            0x8 => 'R0',
+		            0x9 => 'R1',
+		            0xA => 'R2',
+		            0xB => 'R3',
+		            0xC => 'R4',
+		            0xD => 'R5',
+		            0xE => 'R6',
+		            0xF => 'R7'
+		}
+
+		S_TO_I = { 'A' => 0x4,
+		           'B' => 0x5 }
+
+		def initialize(i)
+			@i = i
+		end
+
+		def to_s
+			I_TO_S[@i]
+		end
+
+		def self.from_str(s)
+			new(S_TO_I[s])
+		end
+
+	end
+
+	class Immediate
+		def initialize(value)
+			@value = value
+		end
+
+		def to_s
+			"#" + @value.to_s
+		end
+	end
+
+	class Memref
+		attr_accessor :base, :offset
+		def initialize(base, offset)
+			@base = base
+			@offset = offset
+		end
+
+		def to_s
+			@base ? "@" + @base.to_s : @offset.to_s
+		end
+	end
+
+	def initialize
+		super()
+		@endianness = :big
+		@size = 8
+	end
+
+	def init_opcode_list
+		init_mcs51
+		@opcode_list
+	end
+end
+end
+