metasm 1.0.1 → 1.0.2

data/metasm/cpu/x86_64.rb

@@ -0,0 +1,15 @@
+#    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
+
+class Metasm::X86_64 < Metasm::Ia32
+end
+
+require 'metasm/main'
+require 'metasm/cpu/x86_64/parse'
+require 'metasm/cpu/x86_64/encode'
+require 'metasm/cpu/x86_64/decode'
+require 'metasm/cpu/x86_64/render'
+require 'metasm/cpu/x86_64/debug'
+require 'metasm/cpu/x86_64/compile_c'

data/{lib/metasm → metasm/cpu}/x86_64/compile_c.rb

@@ -4,7 +4,7 @@
 #    Licence is LGPL, see LICENCE in the top-level directory
 
 
-require 'metasm/x86_64/parse'
+require 'metasm/cpu/x86_64/parse'
 require 'metasm/compile_c'
 
 module Metasm
@@ -236,7 +236,7 @@ class CCompiler < C::Compiler
 				e2
 			elsif type.float?
 				raise 'float unhandled'
-			else raise
+			else raise "cannot cast #{e} to #{type}"
 			end
 		elsif e.kind_of? Address
 			make_volatile resolve_address(e), type, rsz
@@ -247,6 +247,7 @@ class CCompiler < C::Compiler
 				e2
 			elsif type.float?
 				raise 'float unhandled'
+			else raise "cannot cast #{e} to #{type}"
 			end
 		else
 			e
@@ -262,7 +263,7 @@ class CCompiler < C::Compiler
 			elsif i >= (1<<64)-0x8000_0000
 				v = Expression[Expression.make_signed(i, 64)]
 			else
-				v = make_volatile(v)
+				v = make_volatile(v, C::BaseType.new(:int))
 				unuse v
 			end
 		end
@@ -417,7 +418,6 @@ class CCompiler < C::Compiler
 					r = reg
 				end
 			end
-		else raise
 		end
 		r
 	end
@@ -512,6 +512,7 @@ class CCompiler < C::Compiler
 					end
 				when :-
 					r = c_cexpr_inner(expr.rexpr)
+					r = resolve_address r if r.kind_of? Address
 					if r.kind_of? Expression
 						unuse l, r
 						l = Address.new(l.modrm.dup)
@@ -574,6 +575,13 @@ class CCompiler < C::Compiler
 						else
 							instr 'mov', l, Reg.new(r.val, l.sz)
 						end
+					elsif l.kind_of? ModRM and r.kind_of? Expression and l.sz == 64
+						rval = r.reduce
+						if !rval.kind_of?(Integer) or rval > 0xffff_ffff or rval < -0x8000_0000
+							r = make_volatile(r, expr.type)
+							unuse r
+						end
+						instr 'mov', l, r
 					else
 						instr 'mov', l, r
 					end
@@ -586,6 +594,7 @@ class CCompiler < C::Compiler
 			l = c_cexpr_inner(expr.lexpr)
 			l = make_volatile(l, expr.type)
 			r = c_cexpr_inner(expr.rexpr)
+			r = make_volatile(r, expr.type) if r.kind_of?(ModRM) and r.sz != l.sz
 			unuse r
 			if expr.lexpr.type.integral? or expr.lexpr.type.pointer?
 				instr 'cmp', l, i_to_i32(r)
@@ -611,7 +620,6 @@ class CCompiler < C::Compiler
 		ft = ft.pointed if ft.pointer?
 		ft = nil if not ft.kind_of? C::Function
 
-		arglist = expr.rexpr.dup
 		regargsmask = @state.regargs.dup
 		if ft
 			ft.args.each_with_index { |a, i|
@@ -639,8 +647,8 @@ class CCompiler < C::Compiler
 		stackargs = expr.rexpr.zip(regargsmask).map { |a, r| a if not r }.compact
 
 		# preserve 16byte stack align under windows
-		stackalign = true if (stackargs + backup).length & 1 == 1
-		instr 'push', rax if stackalign
+		stackalign = true if @state.args_space > 0 and (stackargs + backup).length & 1 == 1
+		instr 'sub', Reg.new(4, @cpusz), Expression[8] if stackalign
 
 		stackargs.reverse_each { |arg|
 			raise 'arg unhandled' if not arg.type.integral? or arg.type.pointer?
@@ -652,7 +660,7 @@ class CCompiler < C::Compiler
 		}
 
 		regargs_unuse = []
-		regargsmask.zip(expr.rexpr).each { |ra, arg|
+		regargsmask.zip(expr.rexpr).reverse_each { |ra, arg|
 			next if not arg or not ra
 			a = c_cexpr_inner(arg)
 			a = resolve_address a if a.kind_of? Address
@@ -666,9 +674,9 @@ class CCompiler < C::Compiler
 
 		if ft.kind_of? C::Function and ft.varargs and @state.args_space == 0
 			# gcc stores here the nr of xmm args passed, real args are passed the standard way
-			# TODO check visualstudio/ms ABI
 			instr 'xor', rax, rax
 			inuse rax
+			regargs_unuse << rax
 		end
 
 
@@ -699,6 +707,7 @@ class CCompiler < C::Compiler
 			else
 				instr 'pop', Reg.new(reg, 64)
 			end
+			inuse getreg(reg)
 		}
 		retreg
 	end
@@ -750,8 +759,10 @@ class CCompiler < C::Compiler
 
 		case op
 		when 'add', 'sub', 'and', 'or', 'xor'
-			r = make_volatile(r, type) if l.kind_of? ModRM and r.kind_of? ModRM
+			r = make_volatile(r, type) if l.kind_of?(ModRM) and r.kind_of?(ModRM)
+			r = make_volatile(r, type) if r.kind_of?(ModRM) and r.sz != l.sz	# add rax, word [moo]
 			unuse r
+			r = Reg.new(r.val, l.sz) if r.kind_of?(Reg) and l.kind_of?(ModRM) and l.sz and l.sz != r.sz     # add byte ptr [rax], bl
 			instr op, l, i_to_i32(r)
 		when 'shr', 'sar', 'shl'
 			if r.kind_of? Expression
@@ -780,6 +791,7 @@ class CCompiler < C::Compiler
 				end
 				instr 'mov', l, ll
 			else
+				r = make_volatile(r, type) if r.kind_of?(ModRM) and r.sz != l.sz
 				instr 'imul', l, r
 			end
 			unuse r
@@ -866,18 +878,21 @@ class CCompiler < C::Compiler
 			l = c_cexpr_inner(expr.lexpr)
 			r = c_cexpr_inner(expr.rexpr)
 			r = make_volatile(r, expr.type) if r.kind_of? ModRM and l.kind_of? ModRM
+			r = make_volatile(r, expr.type) if r.kind_of?(ModRM) and r.sz != l.sz
+			l = make_volatile(l, expr.type) if l.kind_of?(ModRM) and r.kind_of?(Reg) and r.sz != l.sz
 			if l.kind_of? Expression
 				o = { :< => :>, :> => :<, :>= => :<=, :<= => :>= }[o] || o
 				l, r = r, l
 			end
-			unuse l, r
 			if expr.lexpr.type.integral? or expr.lexpr.type.pointer?
-				r = Reg.new(r.val, l.sz) if r.kind_of? Reg and r.sz != l.sz	# XXX
-				instr 'cmp', l, i_to_i32(r)
+				rr = i_to_i32(r)
+				rr = Reg.new(rr.val, l.sz) if rr.kind_of? Reg and rr.sz != l.sz	# XXX
+				instr 'cmp', l, rr
 			elsif expr.lexpr.type.float?
 				raise 'float unhandled'
 			else raise 'bad comparison ' + expr.to_s
 			end
+			unuse l, r
 			op = 'j' + getcc(o, expr.lexpr.type)
 			instr op, Expression[target]
 		when :'!'
@@ -1011,10 +1026,6 @@ class CCompiler < C::Compiler
 
 	def c_program_epilog
 	end
-
-	def check_reserved_name(var)
-		Reg.s_to_i[var.name] or super(var)
-	end
 end
 
 	def new_ccompiler(parser, exe=ExeFormat.new)

data/{lib/metasm → metasm/cpu}/x86_64/debug.rb

@@ -4,7 +4,7 @@
 #    Licence is LGPL, see LICENCE in the top-level directory
 
 
-require 'metasm/x86_64/opcodes'
+require 'metasm/cpu/x86_64/opcodes'
 
 module Metasm
 class X86_64
@@ -15,7 +15,7 @@ class X86_64
 		@dbg_register_flags ||= :rflags
 	end
 
-	def dbg_register_list 
+	def dbg_register_list
 		@dbg_register_list ||= [:rax, :rbx, :rcx, :rdx, :rsi, :rdi, :rbp, :rsp, :r8, :r9, :r10, :r11, :r12, :r13, :r14, :r15, :rip]
 	end
 
@@ -40,10 +40,10 @@ class X86_64
 	end
 	def dbg_func_arg_set(dbg, argnr, arg)
 		if dbg.class.name =~ /win/i
-			list = []
+			list = [:rcx, :rdx, :r8, :r9]
 			off = 0x20
 		else
-			list = []
+			list = [:rdi, :rsi, :rdx, :rcx, :r8, :r9]
 			off = 0
 		end
 		if r = list[argnr]

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

@@ -4,7 +4,7 @@
 #    Licence is LGPL, see LICENCE in the top-level directory
 
 
-require 'metasm/x86_64/opcodes'
+require 'metasm/cpu/x86_64/opcodes'
 require 'metasm/decode'
 
 module Metasm
@@ -15,7 +15,7 @@ class X86_64
 			rm = byte & 7
 
 			if m == 3
-				rm |= 8 if pfx[:rex_b]
+				rm |= 8 if pfx[:rex_b] and (regclass != SimdReg or opsz != 64)	# mm8 -> mm0
 				return regclass.new(rm, opsz)
 			end
 
@@ -33,7 +33,12 @@ class X86_64
 				ii |= 8 if pfx[:rex_x]
 				if ii != 4
 					s = 1 << ((sib >> 6) & 3)
-					i = Reg.new(ii, adsz)
+					if pfx[:mrmvex]
+						i = SimdReg.new(ii, pfx[:mrmvex])
+					else
+						i = Reg.new(ii, adsz)
+					end
+
 				end
 
 				bb = sib & 7
@@ -62,6 +67,7 @@ class X86_64
 				imm = Expression[imm.reduce & ((1 << adsz) - 1)]
 			end
 
+			opsz = pfx[:argsz] if pfx[:argsz]
 			new adsz, opsz, s, i, b, imm, seg
 		end
 	end
@@ -103,7 +109,26 @@ class X86_64
 			v
 		}
 
-		opsz = op.props[:argsz] || (pfx[:rex_w] ? 64 : (pfx[:opsz] ? 16 : (op.props[:auto64] ? 64 : 32)))
+		pfx[:rex_r] = 1 if op.fields[:vex_r] and field_val[:vex_r] == 0
+		pfx[:rex_b] = 1 if op.fields[:vex_b] and field_val[:vex_b] == 0
+		pfx[:rex_x] = 1 if op.fields[:vex_x] and field_val[:vex_x] == 0
+		pfx[:rex_w] = 1 if op.fields[:vex_w] and field_val[:vex_w] == 1
+		di.instruction.prefix = pfx if not di.instruction.prefix and not pfx.empty?	# for opsz(di) + vex_w
+
+		case op.props[:needpfx]
+		when 0x66; pfx.delete :opsz
+		when 0x67; pfx.delete :adsz
+		when 0xF2, 0xF3; pfx.delete :rep
+		end
+
+		if op.props[:setip] and not op.props[:stopexec] and pfx[:seg]
+			case pfx.delete(:seg).val
+			when 1; pfx[:jmphint] = 'hintnojmp'
+			when 3; pfx[:jmphint] = 'hintjmp'
+			end
+		end
+
+		opsz = op.props[:argsz] || opsz(di)
 		adsz = pfx[:adsz] ? 32 : 64
 		mmxsz = (op.props[:xmmx] && pfx[:opsz]) ? 128 : 64
 
@@ -114,21 +139,29 @@ class X86_64
 			when :eeed;   DbgReg.new  field_val_r[a]
 			when :eeet;   TstReg.new  field_val_r[a]
 			when :seg2, :seg2A, :seg3, :seg3A; SegReg.new field_val[a]
-			when :regmmx; SimdReg.new field_val_r[a], mmxsz
+			when :regmmx; SimdReg.new field_val[a], mmxsz	# rex_r ignored
 			when :regxmm; SimdReg.new field_val_r[a], 128
+			when :regymm; SimdReg.new field_val_r[a], 256
 
 			when :farptr; Farptr.decode edata, @endianness, opsz
 			when :i8, :u8, :i16, :u16, :i32, :u32, :i64, :u64; Expression[edata.decode_imm(a, @endianness)]
 			when :i		# 64bit constants are sign-extended from :i32
 				type = (opsz == 64 ? op.props[:imm64] ? :a64 : :i32 : "#{op.props[:unsigned_imm] ? 'a' : 'i'}#{opsz}".to_sym )
- 				v = edata.decode_imm(type, @endianness)
+				v = edata.decode_imm(type, @endianness)
 				v &= 0xffff_ffff_ffff_ffff if opsz == 64 and op.props[:unsigned_imm] and v.kind_of? Integer
 				Expression[v]
 
-			when :mrm_imm;  ModRM.new(adsz, opsz, nil, nil, nil, Expression[edata.decode_imm("a#{adsz}".to_sym, @endianness)], pfx[:seg])
-			when :modrm, :modrmA; ModRM.decode edata, field_val[a], @endianness, adsz, opsz, pfx[:seg], Reg, pfx
-			when :modrmmmx; ModRM.decode edata, field_val[:modrm], @endianness, adsz, mmxsz, pfx[:seg], SimdReg, pfx
-			when :modrmxmm; ModRM.decode edata, field_val[:modrm], @endianness, adsz, 128, pfx[:seg], SimdReg, pfx
+			when :mrm_imm;  ModRM.new(adsz, opsz, nil, nil, nil, Expression[edata.decode_imm("a#{adsz}".to_sym, @endianness)], pfx.delete(:seg))
+			when :modrm; ModRM.decode edata, field_val[:modrm], @endianness, adsz, opsz, pfx.delete(:seg), Reg, pfx
+			when :modrmmmx; ModRM.decode edata, field_val[:modrm], @endianness, adsz, mmxsz, pfx.delete(:seg), SimdReg, pfx.merge(:argsz => op.props[:argsz])
+			when :modrmxmm; ModRM.decode edata, field_val[:modrm], @endianness, adsz, 128, pfx.delete(:seg), SimdReg, pfx.merge(:argsz => op.props[:argsz], :mrmvex => op.props[:mrmvex])
+			when :modrmymm; ModRM.decode edata, field_val[:modrm], @endianness, adsz, 256, pfx.delete(:seg), SimdReg, pfx.merge(:argsz => op.props[:argsz], :mrmvex => op.props[:mrmvex])
+
+			when :vexvreg; Reg.new((field_val[:vex_vvvv] ^ 0xf), opsz)
+			when :vexvxmm; SimdReg.new((field_val[:vex_vvvv] ^ 0xf), 128)
+			when :vexvymm; SimdReg.new((field_val[:vex_vvvv] ^ 0xf), 256)
+			when :i4xmm; SimdReg.new(edata.decode_imm(:u8, @endianness) >> 4, 128)
+			when :i4ymm; SimdReg.new(edata.decode_imm(:u8, @endianness) >> 4, 256)
 
 			when :regfp;  FpReg.new   field_val[a]
 			when :imm_val1; Expression[1]
@@ -143,6 +176,8 @@ class X86_64
 
 		di.bin_length += edata.ptr - before_ptr
 
+		return if edata.ptr > edata.length
+
 		if op.name == 'movsx' or op.name == 'movzx' or op.name == 'movsxd'
 			if op.name == 'movsxd'
 				di.instruction.args[1].sz = 32
@@ -158,12 +193,13 @@ class X86_64
 			else
 				di.instruction.args[0].sz = 32
 			end
+		elsif op.name == 'crc32'
+			di.instruction.args[0].sz = 32
 		end
 
 		# sil => bh
 		di.instruction.args.each { |a| a.val += 12 if a.kind_of? Reg and a.sz == 8 and not pfx[:rex] and a.val >= 4 and a.val <= 8 }
 
-		pfx.delete :seg
 		case pfx.delete(:rep)
 		when :nz
 			if di.opcode.props[:strop]
@@ -195,18 +231,24 @@ class X86_64
 		di
 	end
 
-	def opsz(di)
+	def opsz(di, op=nil)
 		if di and di.instruction.prefix and di.instruction.prefix[:rex_w]; 64
-		elsif di and di.instruction.prefix and di.instruction.prefix[:opsz]; 16
-		elsif di and di.opcode.props[:auto64]; 64
+		elsif di and di.instruction.prefix and di.instruction.prefix[:opsz] and (op || di.opcode).props[:needpfx] != 0x66; 16
+		elsif di and (op || di.opcode).props[:auto64]; 64
 		else 32
 		end
 	end
 
+	def adsz(di, op=nil)
+		if di and di.instruction.prefix and di.instruction.prefix[:adsz] and (op || di.opcode).props[:needpfx] != 0x67; 32
+		else 64
+		end
+	end
+
 	def register_symbols
 		[:rax, :rcx, :rdx, :rbx, :rsp, :rbp, :rsi, :rdi, :r8, :r9, :r10, :r11, :r12, :r13, :r14, :r15]
 	end
-	
+
 	# returns a DecodedFunction from a parsed C function prototype
 	def decode_c_function_prototype(cp, sym, orig=nil)
 		sym = cp.toplevel.symbol[sym] if sym.kind_of?(::String)

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

@@ -4,7 +4,7 @@
 #    Licence is LGPL, see LICENCE in the top-level directory
 
 
-require 'metasm/x86_64/opcodes'
+require 'metasm/cpu/x86_64/opcodes'
 require 'metasm/encode'
 
 module Metasm
@@ -64,7 +64,7 @@ class X86_64
 					# sib
 					or_bits[4]
 
-					@b, @i = @i, @b if @s == 1 and (@i.val_enc == 4 or @b.val_enc == 5)
+					@b, @i = @i, @b if @s == 1 and @i.kind_of?(Reg) and (@i.val_enc == 4 or @b.val_enc == 5)
 
 					raise EncodeError, "Invalid ModRM #{self}" if @i.val == 4
 
@@ -116,23 +116,30 @@ class X86_64
 			case k
 			when :jmp;  {:jmp => 0x3e, :nojmp => 0x2e}[v]
 			when :lock; 0xf0
-			when :rep;  {'repnz' => 0xf2, 'repz' => 0xf3, 'rep' => 0xf2}[v] # TODO
+			when :rep;  {'repnz' => 0xf2, 'repz' => 0xf3, 'rep' => 0xf2}[v]
+			when :jmphint; {'hintjmp' => 0x3e, 'hintnojmp' => 0x2e}[v]
+			when :seg; [0x26, 0x2E, 0x36, 0x3E, 0x64, 0x65][v.val]
 			end
 		}.compact.pack 'C*'
-		pfx << op.props[:needpfx] if op.props[:needpfx]
 
-		rex_w = rex_r = rex_x = rex_b = nil
+		rex_w = rex_r = rex_x = rex_b = 0
 		if op.name == 'movsx' or op.name == 'movzx' or op.name == 'movsxd'
 			case i.args[0].sz
 			when 64; rex_w = 1
 			when 32
 			when 16; pfx << 0x66
 			end
+		elsif op.name == 'crc32'
+			case i.args[1].sz
+			when 64; rex_w = 1
+			when 32;
+			when 16; pfx << 0x66
+			end
 		else
 			opsz = op.props[:argsz] || i.prefix[:sz]
 			oi.each { |oa, ia|
 				case oa
-				when :reg, :reg_eax, :modrm, :modrmA, :mrm_imm
+				when :reg, :reg_eax, :modrm, :mrm_imm
 					raise EncodeError, "Incompatible arg size in #{i}" if ia.sz and opsz and opsz != ia.sz
 					opsz = ia.sz
 				end
@@ -140,7 +147,7 @@ class X86_64
 			opsz ||= 64 if op.props[:auto64]
 			opsz = op.props[:opsz] if op.props[:opsz]	# XXX ?
 			case opsz
-			when 64; rex_w = 1 if not op.props[:auto64]
+			when 64; rex_w = 1 if not op.props[:auto64] and (not op.props[:argsz] or op.props[:opsz] == 64)
 			when 32; raise EncodeError, "Incompatible arg size in #{i}" if op.props[:auto64]
 			when 16; pfx << 0x66
 			end
@@ -168,25 +175,27 @@ class X86_64
 			when :reg
 				set_field[oa, ia.val_enc]
 				if op.fields[:reg][1] == 3
-					rex_r = ia.val_rex
+					rex_r = ia.val_rex || 0
 				else
-					rex_b = ia.val_rex
+					rex_b = ia.val_rex || 0
 				end
-			when :seg3, :seg3A, :seg2, :seg2A, :eeec, :eeed, :eeet, :regfp, :regxmm, :regmmx
+			when :seg3, :seg3A, :seg2, :seg2A, :eeec, :eeed, :eeet, :regfp, :regmmx, :regxmm, :regymm
 				set_field[oa, ia.val & 7]
 				rex_r = 1 if ia.val > 7
 				pfx << 0x66 if oa == :regmmx and op.props[:xmmx] and ia.sz == 128
+			when :vexvreg, :vexvxmm, :vexvymm
+				set_field[:vex_vvvv, ia.val ^ 0xf]
 			when :imm_val1, :imm_val3, :reg_cl, :reg_eax, :reg_dx, :regfp0
 				# implicit
-			when :modrm, :modrmA, :modrmmmx, :modrmxmm
+			when :modrm, :modrmmmx, :modrmxmm, :modrmymm
 				# postpone, but we must set rex now
 				case ia
 				when ModRM
 					ia.encode(0, @endianness)	# could swap b/i
-					rex_x = ia.i.val_rex if ia.i
-					rex_b = ia.b.val_rex if ia.b
+					rex_x = ia.i.val_rex || 0 if ia.i
+					rex_b = ia.b.val_rex || 0 if ia.b
 				when Reg
-					rex_b = ia.val_rex
+					rex_b = ia.val_rex || 0
 				else
 					rex_b = ia.val >> 3
 				end
@@ -196,7 +205,7 @@ class X86_64
 			end
 		}
 
-		if !(op.args & [:modrm, :modrmA, :modrmxmm, :modrmmmx]).empty?
+		if !(op.args & [:modrm, :modrmmmx, :modrmxmm, :modrmymm]).empty?
 			# reg field of modrm
 			regval = (base[-1] >> 3) & 7
 			base.pop
@@ -210,20 +219,26 @@ class X86_64
 			postponed.first[1] = Expression[target, :-, postlabel]
 		end
 
-		if rex_w == 1 or rex_r == 1 or rex_b == 1 or rex_x == 1 or i.args.grep(Reg).find { |r| r.sz == 8 and r.val >= 4 and r.val < 8 }
-			rex ||= 0x40
-			rex |= 1 if rex_b.to_i > 0
-			rex |= 2 if rex_x.to_i > 0
-			rex |= 4 if rex_r.to_i > 0
-			rex |= 8 if rex_w.to_i > 0
+		pfx << op.props[:needpfx] if op.props[:needpfx]
+
+		if op.fields[:vex_r]
+			set_field[:vex_r, rex_r ^ 1]
+			set_field[:vex_x, rex_x ^ 1] if op.fields[:vex_x]
+			set_field[:vex_b, rex_b ^ 1] if op.fields[:vex_b]
+			set_field[:vex_w, rex_w] if op.fields[:vex_w]
+		elsif rex_r + rex_x + rex_b + rex_w >= 1 or i.args.grep(Reg).find { |r| r.sz == 8 and r.val >= 4 and r.val < 8 }
+			rex = 0x40
+			rex |= 1 if rex_b == 1
+			rex |= 2 if rex_x == 1
+			rex |= 4 if rex_r == 1
+			rex |= 8 if rex_w == 1
+			pfx << rex
 		end
-		pfx << rex if rex
 		ret = EncodedData.new(pfx + base.pack('C*'))
 
 		postponed.each { |oa, ia|
 			case oa
-			when :farptr; ed = ia.encode(@endianness, "a#{opsz}".to_sym)
-			when :modrm, :modrmA, :modrmmmx, :modrmxmm
+			when :modrm, :modrmmmx, :modrmxmm, :modrmymm
 				if ia.kind_of? ModRM
 					ed = ia.encode(regval, @endianness)
 					if ed.kind_of?(::Array)
@@ -243,8 +258,22 @@ class X86_64
 			when :mrm_imm; ed = ia.imm.encode("a#{op.props[:adsz] || 64}".to_sym, @endianness)
 			when :i8, :u8, :i16, :u16, :i32, :u32, :i64, :u64; ed = ia.encode(oa, @endianness)
 			when :i
-				type = (opsz == 64 ? op.props[:imm64] ? :a64 : :i32 : "#{op.props[:unsigned_imm] ? 'a' : 'i'}#{opsz}".to_sym)
-			       	ed = ia.encode(type, @endianness)
+				type = if opsz == 64
+					if op.props[:imm64]
+						:a64
+					else
+						if _ia = ia.reduce and _ia.kind_of?(Integer) and _ia > 0 and (_ia >> 63) == 1
+							# handle 0xffffffff_ffffffff -> -1, which should fit in i32
+							ia = Expression[_ia - (1 << 64)]
+						end
+						:i32
+					end
+				else
+					"a#{opsz}".to_sym
+				end
+				ed = ia.encode(type, @endianness)
+			when :i4xmm, :i4ymm
+				ed = ia.val << 4	# u8
 			else raise SyntaxError, "Internal error: want to encode field #{oa.inspect} as arg in #{i}"
 			end