ed/asm_dip
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
03b272d91e
asm_dip/toolchain/fasmg.kl0e/examples/x86/include/80386.inc

2713 lines
64 KiB
PHP
Raw Normal View History

add flat assembler toolchain
2024-11-24 20:13:28 -08:00
define x86 x86
element x86.reg
element x86.r8 : x86.reg + 1
element x86.r16 : x86.reg + 2
element x86.r32 : x86.reg + 4
element al? : x86.r8 + 0
element cl? : x86.r8 + 1
element dl? : x86.r8 + 2
element bl? : x86.r8 + 3
element ah? : x86.r8 + 4
element ch? : x86.r8 + 5
element dh? : x86.r8 + 6
element bh? : x86.r8 + 7
element ax? : x86.r16 + 0
element cx? : x86.r16 + 1
element dx? : x86.r16 + 2
element bx? : x86.r16 + 3
element sp? : x86.r16 + 4
element bp? : x86.r16 + 5
element si? : x86.r16 + 6
element di? : x86.r16 + 7
element eax? : x86.r32 + 0
element ecx? : x86.r32 + 1
element edx? : x86.r32 + 2
element ebx? : x86.r32 + 3
element esp? : x86.r32 + 4
element ebp? : x86.r32 + 5
element esi? : x86.r32 + 6
element edi? : x86.r32 + 7
element x86.sreg
element es? : x86.sreg + 0
element cs? : x86.sreg + 1
element ss? : x86.sreg + 2
element ds? : x86.sreg + 3
element fs? : x86.sreg + 4
element gs? : x86.sreg + 5
element x86.creg
element x86.crx : x86.creg + 0
element x86.drx : x86.creg + 1
element x86.trx : x86.creg + 4
repeat 8, i:0
element cr#i? : x86.crx + i
element dr#i? : x86.drx + i
element tr#i? : x86.trx + i
end repeat
define x86.byte? :1
define x86.word? :2
define x86.dword? :4
define x86.pword? :6
define x86.fword? :6
define x86.qword? :8
x86.mode = 16
macro use16?
x86.mode = 16
end macro
macro use32?
x86.mode = 32
end macro
calminstruction calminstruction?.initsym? var*, val&
publish var, val
end calminstruction
calminstruction calminstruction?.asm? line&
local name, i
initsym name, name.0
match name.i, name
compute i, i+1
arrange name, name.i
publish name, line
arrange line, =assemble name
assemble line
end calminstruction
calminstruction calminstruction?.xcall? instruction*, arguments&
arrange instruction, =call instruction
convert:
match , arguments
jyes ready
local v
match v=,arguments, arguments, <>
jyes recognize
arrange v, arguments
arrange arguments,
recognize:
match (v), v
jyes numeric
match <v>, v
jyes symbolic
append:
arrange instruction, instruction=,v
jump convert
numeric:
compute v, v
symbolic:
local proxy, base, i
initsym base, proxy
initsym i, 0
compute i, i+1
arrange proxy, base.i
publish proxy, v
arrange instruction, instruction=,proxy
jump convert
ready:
assemble instruction
end calminstruction
define @dest @dest
define @src @src
define @src2 @src2
define @aux @aux
iterate context, @dest,@src,@src2,@aux
namespace context
iterate name, size, type, segment_prefix, prefix, opcode_prefix, \
imm, unresolved, displacement, displacement_size, \
address, address_registers, segment, offset, jump_type, \
mode, mod, rm, \
scale, index, base
define name
end iterate
calminstruction x86.parse_operand#context operand
local i, pre, suf, sym
compute segment_prefix, 0
compute prefix, 0
compute opcode_prefix, 0
compute size, 0
compute displacement_size, 0
transform operand
match pre suf, operand
jno no_size_prefix
transform pre, x86
jno no_size_prefix
match :size, pre
jno no_size_prefix
arrange operand, suf
no_size_prefix:
match [address], operand
jyes memory_operand
match =ptr? address, operand
jyes memory_operand
match segment:offset, operand
jyes far_operand
immediate_operand:
compute type, 'imm'
compute imm, +operand
compute unresolved, 0
check defined operand
jyes operand_resolved
compute unresolved, 1
operand_resolved:
check imm eq 1 elementof imm
jno operand_ready
check 1 metadataof (1 metadataof imm) relativeto x86.reg
jyes register_operand
check 1 metadataof imm relativeto x86.sreg
jyes segment_register_operand
operand_ready:
exit
register_operand:
compute type, 'reg'
compute mode, x86.mode
compute mod, 11b
compute rm, 1 metadataof imm - 1 elementof (1 metadataof imm)
check size & size <> 1 metadataof (1 metadataof imm) - x86.reg
jyes operand_sizes_do_not_match
compute size, 1 metadataof (1 metadataof imm) - x86.reg
exit
segment_register_operand:
compute type, 'sreg'
compute mode, x86.mode
compute mod, 11b
compute rm, 1 metadataof imm - x86.sreg
check size & size <> 2 & size <> 4
jyes invalid_operand_size
exit
memory_operand:
compute type, 'mem'
match segment:address, address
jno segment_prefix_ok
check segment eq 1 elementof segment & 1 metadataof segment relativeto x86.sreg
jno invalid_operand
compute segment, 1 metadataof segment - x86.sreg
check segment >= 4
jyes segment_prefix_386
compute segment_prefix, 26h + segment shl 3
jump segment_prefix_ok
segment_prefix_386:
compute segment_prefix, 64h + segment-4
segment_prefix_ok:
compute mode, 0
match pre suf, address
jno no_address_size_prefix
transform pre, x86
jno no_address_size_prefix
match :pre, pre
jno no_address_size_prefix
arrange address, suf
check pre = 2 | pre = 4 | pre = 8
jno invalid_address_size
compute mode, pre shl 3
no_address_size_prefix:
compute scale, 0
compute index, 0
compute base, 0
check size
jyes size_override
compute size, sizeof address
size_override:
compute address, address
compute address_registers, 0
compute i, 1
extract_registers:
check i > elementsof address
jyes registers_extracted
check i metadataof address relativeto x86.r16 | i metadataof address relativeto x86.r32
jno next_term
compute address_registers, address_registers + i elementof address * i scaleof address
next_term:
compute i, i+1
jump extract_registers
registers_extracted:
compute displacement, address - address_registers
check mode
jyes verify_mode
compute mode, x86.mode
check mode = 16 & displacement relativeto 0 & displacement >= 10000h & address_registers eq 0
jno mode_ok
compute mode, 32
jump mode_ok
verify_mode:
check (mode = 16 & 1 metadataof address_registers relativeto x86.r32) | (mode = 32 & 1 metadataof address_registers relativeto x86.r16)
jyes invalid_address
mode_ok:
check address_registers eq 0
jyes direct_address
check 1 metadataof address_registers relativeto x86.r32
jyes address_32bit
check 1 metadataof address_registers relativeto x86.r16
jyes address_16bit
jump invalid_address
direct_address:
compute mod, 0
check mode = 16
jyes direct_address_16bit
direct_address_32bit:
compute rm, 5
compute displacement_size, 4
exit
direct_address_16bit:
compute rm, 6
compute displacement_size, 2
exit
address_16bit:
compute mode, 16
check address_registers relativeto bx+si
jyes rm_0
check address_registers relativeto bx+di
jyes rm_1
check address_registers relativeto bp+si
jyes rm_2
check address_registers relativeto bp+di
jyes rm_3
check address_registers relativeto si
jyes rm_4
check address_registers relativeto di
jyes rm_5
check address_registers relativeto bp
jyes rm_6
check address_registers relativeto bx
jyes rm_7
jump invalid_address
rm_0:
compute rm, 0
jump rm_ok
rm_1:
compute rm, 1
jump rm_ok
rm_2:
compute rm, 2
jump rm_ok
rm_3:
compute rm, 3
jump rm_ok
rm_4:
compute rm, 4
jump rm_ok
rm_5:
compute rm, 5
jump rm_ok
rm_6:
compute rm, 6
jump rm_ok
rm_7:
compute rm, 7
rm_ok:
check displacement relativeto 0
jno displacement_16bit
check displacement = 0 & rm <> 6
jyes displacement_empty
check displacement<80h & displacement>=-80h
jyes displacement_8bit
check displacement-10000h>=-80h & displacement<10000h
jyes displacement_8bit_wrap_16bit
displacement_16bit:
compute displacement_size, 2
compute mod, 2
exit
displacement_empty:
compute displacement_size, 0
compute mod, 0
exit
displacement_8bit_wrap_16bit:
compute displacement, displacement-10000h
displacement_8bit:
compute displacement_size, 1
compute mod, 1
exit
address_32bit:
compute mode,32
check 2 scaleof address_registers = 0
jyes one_register
check 3 scaleof address_registers = 0 & 2 metadataof address_registers relativeto x86.r32
jyes two_registers
jump invalid_address
one_register:
compute scale, 1 scaleof address_registers
compute base, 1 metadataof address_registers - x86.r32
check scale = 1
jyes one_register_unscaled
check base <> 4 & (scale = 4 | scale = 8)
jyes one_register_scaled
check base <> 4 & (scale = 2 | scale = 3 | scale = 5 | scale = 9)
jyes one_register_split
jump invalid_address
one_register_unscaled:
compute rm, base
check rm = 4
jno setup_displacement
compute index, 4
jump setup_displacement
one_register_scaled:
compute rm, 4
compute index, base
compute base, 5
jump index_only
one_register_split:
compute rm, 4
compute index, base
compute scale, scale - 1
jump setup_displacement
two_registers:
compute rm,4
check 1 scaleof address_registers = 1
jyes base_first
check 2 scaleof address_registers = 1
jyes base_second
jump invalid_address
base_first:
compute base, 1 metadataof address_registers - x86.r32
compute index, 2 metadataof address_registers - x86.r32
compute scale, 2 scaleof address_registers
jump process_sib
base_second:
compute base, 2 metadataof address_registers - x86.r32
compute index, 1 metadataof address_registers - x86.r32
compute scale, 1 scaleof address_registers
process_sib:
check index = 4
jyes forbidden_index
check segment_prefix = 36h & index = 5 & scale = 1
jyes switch_to_index
check segment_prefix = 3Eh & base = 5 & scale = 1
jyes switch_to_base
check scale and (scale-1) | scale > 8
jyes invalid_address
jump setup_displacement
forbidden_index:
check scale = 1
jno invalid_address
compute index, base
compute base, 4
jump setup_displacement
switch_to_index:
compute index, base
compute base, 5
jump setup_displacement
switch_to_base:
compute base, index
compute index, 5
jump setup_displacement
setup_displacement:
check displacement relativeto 0
jno displacement_32bit
check displacement = 0 & rm <> 5 & (rm <> 4 | base <> 5)
jyes displacement_empty
check displacement < 80h & displacement >= -80h
jyes displacement_8bit
check displacement-100000000h >= -80h & displacement < 100000000h
jyes displacement_8bit_wrap_32bit
check segment_prefix = 3Eh & base = 5 & index = 5 & scale = 1
jno displacement_32bit
compute scale, 2
jump index_only
displacement_32bit:
compute displacement_size, 4
compute mod, 2
exit
displacement_8bit_wrap_32bit:
compute displacement, displacement-100000000h
jump displacement_8bit
index_only:
compute displacement_size, 4
compute mod, 0
exit
far_operand:
compute type, 'far'
check size & size <> 4 & size <> 6
jyes operand_sizes_do_not_match
exit
invalid_operand:
err 'invalid operand'
exit
invalid_operand_size:
err 'invalid operand size'
exit
operand_sizes_do_not_match:
err 'operand sizes do not match'
exit
invalid_address:
err 'invalid address'
exit
invalid_address_size:
err 'invalid address size'
exit
end calminstruction
calminstruction x86.parse_jump_operand#context operand
match =far? operand, operand
jyes far_jump
match =near? operand, operand
jyes near_jump
match =short? operand, operand
jyes short_jump
compute jump_type, ''
jump parse_operand
far_jump:
compute jump_type, 'far'
jump parse_operand
near_jump:
compute jump_type, 'near'
jump parse_operand
short_jump:
compute jump_type, 'short'
parse_operand:
call x86.parse_operand#context, operand
check type = 'imm'
jno done
check size = 0
jno verify_target_address
compute size, x86.mode shr 3
verify_target_address:
check imm relativeto 0
jno done
check imm < 0
jyes negative
check imm >= 1 shl (size*8)
jno done
out_of_range:
err 'value out of range'
exit
negative:
check imm < - 1 shl (size*8-1)
jyes out_of_range
compute imm, imm and (1 shl (size*8) - 1)
done:
end calminstruction
calminstruction x86.select_operand_prefix#context size*
check (size = 2 & x86.mode = 32) | (size = 4 & x86.mode = 16)
jno no_prefix
compute prefix, 66h
no_prefix:
check size <> 0 & size <> 2 & size <> 4
jno done
err 'invalid operand size'
done:
end calminstruction
calminstruction x86.store_instruction#context opcode*,reg*,imm_size:0,immediate
check segment_prefix
jno segment_prefix_ok
check mode = 16 & ( rm = 2 | rm = 3 | ( mod > 0 & rm = 6 ) )
jyes ss_segment_default
check mode = 32 & ( ( mod > 0 & rm = 5 ) | ( rm = 4 & base = 4 ) | ( mod > 0 & rm = 4 & base = 5 ) )
jyes ss_segment_default
ds_segment_default:
check segment_prefix = 3Eh
jyes segment_prefix_ok
jump store_segment_prefix
ss_segment_default:
check segment_prefix = 36h
jyes segment_prefix_ok
store_segment_prefix:
emit 1, segment_prefix
segment_prefix_ok:
check mod <> 11b & mode <> x86.mode
jno addressing_prefix_ok
emit 1, 67h
addressing_prefix_ok:
check prefix
jno operand_prefix_ok
emit 1, prefix
operand_prefix_ok:
check opcode_prefix
jno opcode_prefix_ok
emit 1, opcode_prefix
opcode_prefix_ok:
asm db opcode
emit 1, mod shl 6 + (reg and 111b) shl 3 + rm and 111b
check mod <> 11b & rm = 4 & mode = 32
jno sib_ok
emit 1, (bsf scale) shl 6 + (index and 111b) shl 3 + base and 111b
sib_ok:
check displacement_size = 1
jyes displacement_8bit
check displacement_size = 2
jyes displacement_16bit
check displacement_size = 4
jno displacement_ok
displacement_32bit:
asm dd displacement
jump displacement_ok
displacement_16bit:
asm dw displacement
jump displacement_ok
displacement_8bit:
emit 1, displacement
displacement_ok:
check imm_size = 1
jyes immediate_8bit
check imm_size = 2
jyes immediate_16bit
check imm_size = 4
jno immediate_ok
immediate_32bit:
compute imm, +immediate
asm dd imm
jump immediate_ok
immediate_16bit:
compute imm, +immediate
asm dw imm
jump immediate_ok
immediate_8bit:
compute imm, +immediate
emit 1, imm
jump immediate_ok
immediate_ok:
end calminstruction
end namespace
end iterate
calminstruction x86.store_operand_prefix size*
check (size = 2 & x86.mode = 32) | (size = 4 & x86.mode = 16)
jno no_prefix
emit 1, 66h
exit
no_prefix:
check size <> 0 & size <> 2 & size <> 4
jno done
err 'invalid operand size'
done:
end calminstruction
iterate <instr,basecode>, add,0, or,8, adc,10h, sbb,18h, and,20h, sub,28h, xor,30h, cmp,38h
calminstruction instr? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
local opcode, rm, size
compute opcode, basecode
check @dest.size = 0 & @src.size = 0
jyes operand_size_not_specified
check @dest.size <> 0 & @src.size <> 0 & @dest.size <> @src.size
jyes operand_sizes_do_not_match
compute size, @dest.size or @src.size
main:
check @src.type = 'reg' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes reg_rm
check @src.type = 'mem' & @dest.type = 'reg'
jyes rm_reg
check @src.type = 'imm' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes rm_imm
err 'invalid combination of operands'
exit
operand_size_not_specified:
err 'operand size not specified'
compute size, 0
jump main
operand_sizes_do_not_match:
err 'operand sizes do not match'
compute size, 0
jump main
reg_rm:
check size > 1
jno reg_rm_store
call x86.select_operand_prefix@dest, size
compute opcode, opcode + 1
reg_rm_store:
call x86.store_instruction@dest, opcode,@src.rm
exit
rm_reg:
compute opcode, opcode + 2
check size > 1
jno rm_reg_store
call x86.select_operand_prefix@src, size
compute opcode, opcode + 1
rm_reg_store:
call x86.store_instruction@src, opcode,@dest.rm
exit
rm_imm:
check size > 1
jyes rm_imm_word
check @dest.type = 'reg' & @dest.rm = 0
jyes al_imm
compute opcode, opcode shr 3
xcall x86.store_instruction@dest, (80h),opcode,byte,@src.imm
exit
al_imm:
emit 1, opcode+4
emit 1, @src.imm
exit
rm_imm_word:
call x86.select_operand_prefix@dest, size
check @src.imm eqtype 0.0
jno rm_imm_optimize
asm virtual at 0
asm emit size: @src.imm
asm load @src.imm:size from 0
asm end virtual
compute @src.imm, +@src.imm
rm_imm_optimize:
check @src.imm relativeto 0 & @src.imm<80h & @src.imm>=-80h
jyes rm_simm
check size = 2 & @src.imm relativeto 0 & @src.imm-10000h>=-80h & @src.imm<10000h
jyes rm_simm_wrap
check size = 4 & @src.imm relativeto 0 & @src.imm-100000000h>=-80h & @src.imm<100000000h
jyes rm_simm_wrap
check @dest.type = 'reg' & @dest.rm = 0
jyes ax_imm
compute rm, opcode shr 3
xcall x86.store_instruction@dest, (81h),rm,size,@src.imm
exit
ax_imm:
check @dest.prefix
jno ax_imm_prefix_ok
emit 1, @dest.prefix
ax_imm_prefix_ok:
emit 1, opcode+5
check size = 4
jyes imm32
asm dw @src.imm
exit
imm32:
asm dd @src.imm
exit
rm_simm_wrap:
compute @src.imm, @src.imm - 1 shl (size shl 3)
rm_simm:
compute rm, opcode shr 3
xcall x86.store_instruction@dest, (83h),rm,byte,@src.imm
end calminstruction
end iterate
iterate <instr,postbyte>, not,2, neg,3, mul,4, div,6, idiv,7
calminstruction instr? src*
call x86.parse_operand@src, src
check @src.size = 0
jyes operand_size_not_specified
main:
check @src.type = 'mem' | @src.type = 'reg'
jno invalid_operand
check @src.size > 1
jyes rm_word
xcall x86.store_instruction@src, (0F6h),(postbyte)
exit
rm_word:
call x86.select_operand_prefix@src, @src.size
xcall x86.store_instruction@src, (0F7h),(postbyte)
exit
operand_size_not_specified:
err 'operand size not specified'
jump main
invalid_operand:
err 'invalid operand'
exit
end calminstruction
end iterate
calminstruction mov? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
local ext, rm, size
check @dest.size = 0 & @src.size = 0 & @dest.type <> 'sreg'
jyes operand_size_not_specified
check @dest.size <> 0 & @src.size <> 0 & @dest.size <> @src.size
jyes operand_sizes_do_not_match
compute size, @dest.size or @src.size
main:
check @src.type = 'reg' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes mov_rm_reg
check @src.type = 'mem' & @dest.type = 'reg'
jyes mov_reg_mem
check @src.type = 'imm' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes mov_rm_imm
check @src.type = 'reg' & @dest.type = 'imm'
jyes mov_creg_reg
check @src.type = 'sreg' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes mov_rm_sreg
check @dest.type = 'sreg' & @dest.rm <> 1 & ( @src.type = 'reg' | @src.type = 'mem' )
jyes mov_sreg_rm
invalid_combination_of_operands:
err 'invalid combination of operands'
exit
operand_size_not_specified:
err 'operand size not specified'
compute size, 0
jump main
operand_sizes_do_not_match:
err 'operand sizes do not match'
compute size, 0
jump main
mov_rm_reg:
check @src.type = 'reg' & @dest.type = 'mem' & @src.rm = 0 & @dest.address_registers eq 0
jyes mov_dirmem_ax
check size > 1
jno mov_reg_rm_8bit
call x86.select_operand_prefix@dest, size
xcall x86.store_instruction@dest, (89h),@src.rm
exit
mov_reg_rm_8bit:
xcall x86.store_instruction@dest, (88h),@src.rm
exit
mov_reg_mem:
check @src.type = 'mem' & @dest.type = 'reg' & @dest.rm = 0 & @src.address_registers eq 0
jyes mov_ax_dirmem
check size > 1
jno mov_mem_reg_8bit
call x86.select_operand_prefix@src, size
xcall x86.store_instruction@src, (8Bh),@dest.rm
exit
mov_mem_reg_8bit:
xcall x86.store_instruction@src, (8Ah),@dest.rm
exit
mov_dirmem_ax:
check @dest.segment_prefix = 0 | @dest.segment_prefix = 3Eh
jyes dest_seg_ok
emit 1, @dest.segment_prefix
dest_seg_ok:
check @dest.mode = x86.mode
jyes dest_addr_size_ok
emit 1, 67h
dest_addr_size_ok:
check size > 1
jno mov_dirmem_al
call x86.store_operand_prefix, size
emit 1, 0A3h
jump dest_displacement
mov_dirmem_al:
emit 1, 0A2h
dest_displacement:
check @dest.mode = 16
jyes dest_displacement_16bit
asm dd @dest.address
exit
dest_displacement_16bit:
asm dw @dest.address
exit
mov_ax_dirmem:
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh
jyes src_seg_ok
emit 1, @src.segment_prefix
src_seg_ok:
check @src.mode = x86.mode
jyes src_addr_size_ok
emit 1, 67h
src_addr_size_ok:
check size > 1
jno mov_al_dirmem
call x86.store_operand_prefix, size
emit 1, 0A1h
jump src_displacement
mov_al_dirmem:
emit 1, 0A0h
src_displacement:
check @src.mode = 16
jyes src_displacement_16bit
asm dd @src.address
exit
src_displacement_16bit:
asm dw @src.address
exit
mov_rm_imm:
check @dest.type = 'mem'
jyes mov_mem_imm
check @dest.type = 'reg' & 1 metadataof (1 metadataof @src.imm) relativeto x86.creg & @src.imm relativeto 1 elementof @src.imm
jyes mov_reg_creg
mov_reg_imm:
check size > 1
jno mov_reg_imm_8bit
call x86.store_operand_prefix, size
emit 1, 0B8h + @dest.rm
check size = 2
jyes src_imm_16bit
asm dd @src.imm
exit
src_imm_16bit:
asm dw @src.imm
exit
mov_reg_imm_8bit:
emit 1, 0B0h + @dest.rm
emit 1, @src.imm
exit
mov_mem_imm:
check size > 1
jno mov_mem_imm_8bit
call x86.select_operand_prefix@dest, size
xcall x86.store_instruction@dest, (0C7h),(0),size,@src.imm
exit
mov_mem_imm_8bit:
xcall x86.store_instruction@dest, (0C6h),(0),byte,@src.imm
exit
mov_reg_creg:
check @dest.size = 4
jno invalid_operand_size
compute ext, 20h + 1 metadataof (1 metadataof @src.imm) - x86.creg
compute rm, 1 metadataof @src.imm - 1 elementof (1 metadataof @src.imm)
xcall x86.store_instruction@dest, <0Fh,ext>,rm
exit
mov_creg_reg:
check 1 metadataof (1 metadataof @dest.imm) relativeto x86.creg & @dest.imm relativeto 1 elementof @dest.imm
jno invalid_combination_of_operands
check @src.size = 4
jno invalid_operand_size
compute ext, 22h + 1 metadataof (1 metadataof @dest.imm) - x86.creg
compute rm, 1 metadataof @dest.imm - 1 elementof (1 metadataof @dest.imm)
xcall x86.store_instruction@src, <0Fh,ext>,rm
exit
mov_rm_sreg:
check @dest.type = 'mem'
jyes mov_mem_sreg
mov_reg_sreg:
check size > 1
jno invalid_operand_size
call x86.select_operand_prefix@dest, size
jump mov_rm_sreg_store
mov_mem_sreg:
check size and not 2
jyes invalid_operand_size
mov_rm_sreg_store:
xcall x86.store_instruction@dest, (8Ch),@src.rm
exit
mov_sreg_rm:
check size = 1
jyes invalid_operand_size
xcall x86.store_instruction@src, (8Eh),@dest.rm
exit
invalid_operand_size:
err 'invalid operand size'
exit
end calminstruction
calminstruction test? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
local ext, rm, size
check @dest.size = 0 & @src.size = 0
jyes operand_size_not_specified
check @dest.size <> 0 & @src.size <> 0 & @dest.size <> @src.size
jyes operand_sizes_do_not_match
compute size, @dest.size or @src.size
main:
check @src.type = 'reg' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes test_reg_rm
check @src.type = 'mem' & @dest.type = 'reg'
jyes test_mem_reg
check @src.type = 'imm' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes test_rm_imm
invalid_combination_of_operands:
err 'invalid combination of operands'
exit
operand_size_not_specified:
err 'operand size not specified'
compute size, 0
jump main
operand_sizes_do_not_match:
err 'operand sizes do not match'
compute size, 0
jump main
test_reg_rm:
check size > 1
jno test_reg_rm_8bit
call x86.select_operand_prefix@dest, size
xcall x86.store_instruction@dest, (85h),@src.rm
exit
test_reg_rm_8bit:
xcall x86.store_instruction@dest, (84h),@src.rm
exit
test_mem_reg:
check size > 1
jno test_mem_reg_8bit
call x86.select_operand_prefix@src, size
xcall x86.store_instruction@src, (85h),@dest.rm
exit
test_mem_reg_8bit:
xcall x86.store_instruction@src, (84h),@dest.rm
exit
test_rm_imm:
check size > 1
jno test_rm_imm_8bit
check @dest.type = 'reg' & @dest.rm = 0
jyes test_ax_imm
call x86.select_operand_prefix@dest, size
xcall x86.store_instruction@dest, (0F7h),(0),size,@src.imm
exit
test_ax_imm:
call x86.store_operand_prefix, size
emit 1, 0A9h
check size = 2
jyes src_imm_16bit
asm dd @src.imm
exit
src_imm_16bit:
asm dw @src.imm
exit
test_rm_imm_8bit:
check @dest.type = 'reg' & @dest.rm = 0
jyes test_al_imm
xcall x86.store_instruction@dest, (0F6h),(0),byte,@src.imm
exit
test_al_imm:
emit 1, 0A8h
emit 1, @src.imm
exit
end calminstruction
calminstruction xchg? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
local ext, rm, size
check @dest.size = 0 & @src.size = 0
jyes operand_size_not_specified
check @dest.size <> 0 & @src.size <> 0 & @dest.size <> @src.size
jyes operand_sizes_do_not_match
compute size, @dest.size or @src.size
main:
check @src.type = 'reg' & @dest.type = 'reg'
jyes xchg_reg_reg
check @src.type = 'reg' & @dest.type = 'mem'
jyes xchg_reg_rm
check @src.type = 'mem' & @dest.type = 'reg'
jyes xchg_rm_reg
invalid_combination_of_operands:
err 'invalid combination of operands'
exit
operand_size_not_specified:
err 'operand size not specified'
compute size, 0
jump main
operand_sizes_do_not_match:
err 'operand sizes do not match'
compute size, 0
jump main
xchg_reg_reg:
check @src.rm = 0 | @dest.rm = 0
jno xchg_rm_reg
check size > 1
jno xchg_rm_reg_8bit
call x86.store_operand_prefix, size
emit 1, 90h + @src.rm + @dest.rm
exit
xchg_reg_rm:
check size > 1
jno xchg_reg_rm_8bit
call x86.select_operand_prefix@dest, size
xcall x86.store_instruction@dest, (87h),@src.rm
exit
xchg_reg_rm_8bit:
xcall x86.store_instruction@dest, (86h),@src.rm
exit
xchg_rm_reg:
check size > 1
jno xchg_rm_reg_8bit
call x86.select_operand_prefix@src, size
xcall x86.store_instruction@src, (87h),@dest.rm
exit
xchg_rm_reg_8bit:
xcall x86.store_instruction@src, (86h),@dest.rm
exit
end calminstruction
iterate <instr,postbyte>, inc,00 ,dec,01
calminstruction instr? dest*
call x86.parse_operand@dest, dest
check @dest.size
jyes main
err 'operand size not specified'
main:
check @dest.type = 'reg'
jyes inc_reg
check @dest.type = 'mem'
jyes inc_rm
err 'invalid operand'
exit
inc_reg:
check @dest.size > 1
jno inc_rm_8bit
call x86.store_operand_prefix, @dest.size
emit 1, 40h + @dest.rm + 0x#postbyte shl 3
exit
inc_rm:
check @dest.size > 1
jno inc_rm_8bit
call x86.select_operand_prefix@dest, @dest.size
xcall x86.store_instruction@dest, (0FFh),(postbyte)
exit
inc_rm_8bit:
xcall x86.store_instruction@dest, (0FEh),(postbyte)
end calminstruction
end iterate
calminstruction imul? dest*,src&
local size
call x86.parse_operand@dest, dest
match , src
jyes imul_rm
local src1, src2
match src1 =, src2, src
jyes imul_second_source
call x86.parse_operand@src, src
check @dest.size = 0 & @src.size = 0
jyes operand_size_not_specified
check @dest.size <> 0 & @src.size <> 0 & @dest.size <> @src.size
jyes operand_sizes_do_not_match
compute size, @dest.size or @src.size
check @dest.type = 'reg' & (@src.type = 'reg' | @src.type = 'mem')
jyes imul_reg_rm
check @src.type = 'imm' & @dest.type = 'reg'
jno invalid_combination_of_operands
compute @aux.type, @src.type
compute @aux.imm, @src.imm
compute @src.type, @dest.type
compute @src.mod, @dest.mod
compute @src.rm, @dest.rm
jump main
imul_second_source:
call x86.parse_operand@src, src1
call x86.parse_operand@aux, src2
check @dest.size = 0 & @src.size = 0 & @aux.size = 0
jyes operand_size_not_specified
compute size, @dest.size or @src.size or @aux.size
check (@dest.size & @dest.size <> size) | (@src.size & @src.size <> size) | (@aux.size & @aux.size <> size)
jyes operand_sizes_do_not_match
jump main
operand_size_not_specified:
err 'operand size not specified'
compute size, 0
jump main
operand_sizes_do_not_match:
err 'operand sizes do not match'
compute size, 0
jump main
main:
check @aux.type = 'imm' & ( @src.type = 'mem' | @src.type = 'reg' ) & @dest.type = 'reg'
jyes imul_reg_rm_imm
invalid_combination_of_operands:
err 'invalid combination of operands'
exit
imul_rm:
check @dest.size
jyes imul_rm_size_ok
err 'operand size not specified'
imul_rm_size_ok:
check @dest.type = 'mem' | @dest.type = 'reg'
jno invalid_combination_of_operands
check @dest.size > 1
jno imul_rm_8bit
call x86.select_operand_prefix@dest, @dest.size
xcall x86.store_instruction@dest, (0F7h),(5)
exit
imul_rm_8bit:
xcall x86.store_instruction@dest, (0F6h),(5)
exit
imul_reg_rm:
call x86.select_operand_prefix@src, size
xcall x86.store_instruction@src, <0Fh,0AFh>,@dest.rm
exit
imul_reg_rm_imm:
call x86.select_operand_prefix@src, size
check @aux.imm eqtype 0.0
jno imul_reg_rm_imm_optimize
asm virtual at 0
asm emit size: @aux.imm
asm load @aux.imm:size from 0
asm end virtual
compute @aux.imm, +@aux.imm
imul_reg_rm_imm_optimize:
check @aux.imm relativeto 0 & @aux.imm < 80h & @aux.imm >= -80h
jyes imul_reg_rm_simm
check size = 2 & @aux.imm relativeto 0 & @aux.imm - 10000h >= -80h & @aux.imm < 10000h
jyes imul_reg_rm_simm_wrap
check size = 4 & @aux.imm relativeto 0 & @aux.imm - 100000000h >= -80h & @aux.imm < 100000000h
jyes imul_reg_rm_simm_wrap
xcall x86.store_instruction@src, (69h),@dest.rm,size,@aux.imm
exit
imul_reg_rm_simm_wrap:
compute @aux.imm, @aux.imm - 1 shl (size shl 3)
imul_reg_rm_simm:
xcall x86.store_instruction@src, (6Bh),@dest.rm,byte,@aux.imm
exit
end calminstruction
calminstruction x86.push_instruction size:0,src*
call x86.parse_operand@src, src
check size <> 0 & @src.size and not size
jyes invalid_operand_size
compute size, size or @src.size
check size = 0 | size = 2 | size = 4
jyes main
invalid_operand_size:
err 'invalid operand size'
main:
check @src.type = 'mem'
jyes push_mem
check @src.type = 'reg'
jyes push_reg
check @src.type = 'sreg'
jyes push_sreg
check @src.type = 'imm'
jyes push_imm
err 'invalid operand'
exit
push_mem:
call x86.select_operand_prefix@src, size
xcall x86.store_instruction@src, (0FFh),(110b)
exit
push_reg:
call x86.store_operand_prefix, size
emit 1, 50h + @src.rm
exit
push_sreg:
call x86.store_operand_prefix, size
check @src.rm >= 4
jyes push_sreg_386
emit 1, 6 + @src.rm shl 3
exit
push_sreg_386:
emit 1, 0Fh
emit 1, 0A0h + (@src.rm-4) shl 3
exit
push_imm:
check size
jyes push_imm_size_ok
check x86.mode = 16
jyes push_imm_16bit
compute size, 4
jump push_imm_size_ok
push_imm_16bit:
compute size, 2
push_imm_size_ok:
call x86.store_operand_prefix, size
check @src.imm eqtype 0.0
jno push_imm_optimize
asm virtual at 0
asm emit size: @src.imm
asm load @src.imm:size from 0
asm end virtual
compute @src.imm, +@src.imm
push_imm_optimize:
check @src.imm relativeto 0 & @src.imm < 80h & @src.imm >= -80h
jyes push_simm
check size = 2 & @src.imm relativeto 0 & @src.imm - 10000h >= -80h & @src.imm < 10000h
jyes push_simm_wrap
check size = 4 & @src.imm relativeto 0 & @src.imm - 100000000h >= -80h & @src.imm < 100000000h
jyes push_simm_wrap
emit 1, 68h
check size = 2
jyes src_imm_16bit
asm dd @src.imm
exit
src_imm_16bit:
asm dw @src.imm
exit
push_simm_wrap:
compute @src.imm, @src.imm - 1 shl (size shl 3)
push_simm:
emit 1, 6Ah
emit 1, @src.imm
exit
end calminstruction
calminstruction x86.pop_instruction size:0,dest*
call x86.parse_operand@dest, dest
check size <> 0 & @dest.size and not size
jyes invalid_operand_size
compute size, size or @dest.size
check size = 0 | size = 2 | size = 4
jyes main
invalid_operand_size:
err 'invalid operand size'
main:
check @dest.type = 'mem'
jyes pop_mem
check @dest.type = 'reg'
jyes pop_reg
check @dest.type = 'sreg'
jyes pop_sreg
invalid_operand:
err 'invalid operand'
exit
pop_mem:
call x86.select_operand_prefix@dest, size
xcall x86.store_instruction@dest, (8Fh),(0)
exit
pop_reg:
call x86.store_operand_prefix, size
emit 1, 58h + @dest.rm
exit
pop_sreg:
check @dest.rm = 1
jyes invalid_operand
call x86.store_operand_prefix, size
check @dest.rm >= 4
jyes pop_sreg_386
emit 1, 7 + @dest.rm shl 3
exit
pop_sreg_386:
emit 1, 0Fh
emit 1, 0A1h + (@dest.rm-4) shl 3
exit
end calminstruction
iterate reg, ax,cx,dx,bx,sp,bp,si,di, eax,ecx,edx,ebx,esp,ebp,esi,edi, es,cs,ss,ds,fs,gs
define x86.compact.reg? {reg}
end iterate
iterate <instr,handler,size>, push,push_instruction,0, pushw,push_instruction,2, pushd,push_instruction,4, \
pop,pop_instruction,0, popw,pop_instruction,2, popd,pop_instruction,4
calminstruction instr? operand
local head, tail
match head tail, operand
jno plain
transform head, x86.compact
jno plain
match {head}, head
jno plain
loop:
xcall x86.handler, (size),head
match head tail, tail
jno final
transform head, x86.compact
jno error
match {head}, head
jyes loop
error:
err 'only register operands allowed in compact syntax'
exit
final:
transform tail, x86.compact
jno error
match {operand}, tail
jno error
plain:
xcall x86.handler, (size),operand
end calminstruction
end iterate
iterate <instr,opcode>, ret,0C2h, retn,0C2h, retf,0CAh
calminstruction instr? operand
match , operand
jyes ret_short
check operand
jno ret_short
emit 1, opcode
asm dw operand
exit
ret_short:
emit 1, opcode + 1
end calminstruction
end iterate
iterate <instr,size,opcode>, retw,2,0C2h, retnw,2,0C2h, retd,4,0C2h, retnd,4,0C2h, retfw,2,0CAh, retfd,4,0CAh
calminstruction instr? operand
xcall x86.store_operand_prefix, (size)
match , operand
jyes ret_short
emit 1, opcode
asm dw operand
exit
ret_short:
emit 1, opcode + 1
end calminstruction
end iterate
calminstruction lea? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @src.type = 'mem' & @dest.type = 'reg'
jno invalid_combination_of_operands
call x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, (8Dh),@dest.rm
exit
invalid_combination_of_operands:
err 'invalid combination of operands'
end calminstruction
iterate <instr,opcode>, les,0C4h, lds,0C5h, lss,<0Fh,0B2h>, lfs,<0Fh,0B4h>, lgs,<0Fh,0B5h>
calminstruction instr? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check (@dest.size = 2 & (@src.size <> 0 & @src.size <> 4)) | (@dest.size = 4 & (@src.size <> 0 & @src.size <> 6))
jyes invalid_operand_size
check @src.type = 'mem' & @dest.type = 'reg'
jno invalid_combination_of_operands
call x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, <opcode>,@dest.rm
exit
invalid_operand_size:
err 'invalid operand size'
exit
invalid_combination_of_operands:
err 'invalid combination of operands'
end calminstruction
end iterate
iterate <instr,postbyte>, rol,0, ror,1, rcl,2, rcr,3, shl,4, sal, 4, shr,5, sar,7
calminstruction instr? dest*,cnt*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, cnt
check @dest.size = 0
jyes operand_size_not_specified
check @src.size and not 1
jyes invalid_operand_size
main:
check @src.type = 'reg' & @src.size = 1 & @src.rm = 1 & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes shift_rm_cl
check @src.type = 'imm' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes shift_rm_imm
err 'invalid combination of operands'
exit
shift_rm_cl:
check @dest.size > 1
jno shift_r8_cl
call x86.select_operand_prefix@dest, @dest.size
xcall x86.store_instruction@dest, (0D3h),(postbyte)
exit
shift_r8_cl:
xcall x86.store_instruction@dest, (0D2h),(postbyte)
exit
shift_rm_imm:
check @dest.size > 1
jno shift_rm8_imm
call x86.select_operand_prefix@dest, @dest.size
check @src.imm = 1
jyes shift_rm_1
xcall x86.store_instruction@dest, (0C1h),(postbyte),byte,@src.imm
exit
shift_rm_1:
xcall x86.store_instruction@dest, (0D1h),(postbyte)
exit
shift_rm8_imm:
check @src.imm = 1
jyes shift_rm8_1
xcall x86.store_instruction@dest, (0C0h),(postbyte),byte,@src.imm
exit
shift_rm8_1:
xcall x86.store_instruction@dest, (0D0h),(postbyte)
exit
operand_size_not_specified:
err 'operand size not specified'
jump main
invalid_operand_size:
err 'invalid operand size'
jump main
end calminstruction
end iterate
iterate <instr,ext>, shld,0A4h, shrd,0ACh
calminstruction instr? dest*,src*,cnt*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
call x86.parse_operand@aux, cnt
check @aux.size and not 1
jyes invalid_operand_size
check @dest.size and not @src.size
jno main
err 'operand sizes do not match'
main:
check @aux.type = 'reg' & @aux.size = 1 & @aux.rm = 1 & @src.type = 'reg' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes shld_cl
check @aux.type = 'imm' & @src.type = 'reg' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes shld_imm
err 'invalid combination of operands'
exit
shld_cl:
call x86.select_operand_prefix@dest, @src.size
xcall x86.store_instruction@dest, <0Fh,ext+1>,@src.rm
exit
shld_imm:
call x86.select_operand_prefix@dest, @src.size
xcall x86.store_instruction@dest, <0Fh,ext>,@src.rm,byte,@aux.imm
exit
invalid_operand_size:
err 'invalid operand size'
end calminstruction
end iterate
iterate <instr,postbyte>, bt,4, bts,5, btr,6, btc,7
calminstruction instr? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @src.type = 'reg' & (@dest.type = 'mem' | @dest.type = 'reg')
jyes bt_rm_reg
check @src.type = 'imm' & (@dest.type = 'mem' | @dest.type = 'reg')
jyes bt_rm_imm
err 'invalid combination of operands'
exit
bt_rm_reg:
local opcode
check @dest.size and not @src.size
jno bt_rm_reg_ok
err 'operand sizes do not match'
bt_rm_reg_ok:
compute opcode, 0A3h+(postbyte-4) shl 3
call x86.select_operand_prefix@dest, @src.size
xcall x86.store_instruction@dest, <0Fh,opcode>,@src.rm
exit
bt_rm_imm:
check @src.size and not 1
jno bt_rm_imm_ok
err 'invalid operand size'
bt_rm_imm_ok:
check @dest.size
jno bt_rm_imm_prefix_ok
call x86.select_operand_prefix@dest, @dest.size
bt_rm_imm_prefix_ok:
xcall x86.store_instruction@dest, <0Fh,0BAh>,(postbyte),byte,@src.imm
end calminstruction
end iterate
iterate <instr,ext>, bsf,0BCh, bsr,0BDh
calminstruction instr? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @dest.type = 'reg' & (@src.type = 'mem' | @src.type = 'reg')
jyes bsf_reg_rm
err 'invalid combination of operands'
exit
bsf_reg_rm:
check @src.size and not @dest.size
jno bsf_reg_rm_ok
err 'operand sizes do not match'
bsf_reg_rm_ok:
call x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, <0Fh,ext>,@dest.rm
end calminstruction
end iterate
iterate <instr,ext>, movzx,0B6h, movsx,0BEh
calminstruction instr? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @dest.size > @src.size
jyes size_ok
err 'operand sizes do not match'
size_ok:
check @dest.type = 'reg' & (@src.type = 'mem' | @src.type = 'reg')
jyes operands_ok
err 'invalid combination of operands'
exit
operands_ok:
check @src.size = 2
jyes movzx_word
check @src.size = 1 | (@src.size = 0 & @dest.size = 2)
jyes movzx_byte
check @src.size
jyes invalid_operand_size
err 'operand size not specified'
movzx_word:
call x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, <0Fh,ext+1>,@dest.rm
exit
movzx_byte:
call x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, <0Fh,ext>,@dest.rm
exit
invalid_operand_size:
err 'invalid operand size'
end calminstruction
end iterate
iterate <cond,code>, o,0, no,1, c,2, b,2, nae,2, nc,3, nb,3, ae,3, z,4, e,4, nz,5, ne,5, na,6, be,6, a,7, nbe,7, \
s,8, ns,9, p,0Ah, pe,0Ah, np,0Bh, po,0Bh, l,0Ch, nge,0Ch, nl,0Dh, ge,0Dh, ng,0Eh, le,0Eh, g,0Fh, nle,0Fh
calminstruction set#cond? dest*
call x86.parse_operand@dest, dest
check @dest.size > 1
jno size_ok
err 'invalid operand size'
size_ok:
check @dest.type = 'reg' | @dest.type = 'mem'
jyes operand_ok
err 'invalid operand'
exit
operand_ok:
xcall x86.store_instruction@dest, <0Fh,90h+code>,(0)
end calminstruction
end iterate
calminstruction call? dest*
call x86.parse_jump_operand@dest, dest
check @dest.type = 'imm'
jyes call_imm
check @dest.type = 'mem' | @dest.type = 'reg'
jyes call_rm
check @dest.type = 'far'
jyes call_direct_far
invalid_operand:
err 'invalid operand'
exit
call_direct_far:
check @dest.jump_type & @dest.jump_type <> 'far'
jyes invalid_operand
check @dest.size = 0
jyes prefix_ok
local size
compute size, @dest.size - 2
call x86.store_operand_prefix, size
prefix_ok:
check @dest.size and not 4 & @dest.size and not 6
jyes invalid_operand
emit 1, 9Ah
check (@dest.size = 0 & x86.mode = 16) | @dest.size = 4
jyes far_dword
asm dd @dest.offset
asm dw @dest.segment
exit
far_dword:
asm dw @dest.offset,@dest.segment
exit
call_rm:
check @dest.size = 6
jyes call_rm_pword
check @dest.size = 4
jyes call_rm_dword
check @dest.size = 2
jyes call_rm_word
check @dest.size
jyes invalid_operand
check @dest.jump_type = 'far'
jyes call_rm_far
check @dest.jump_type = 'near'
jyes call_rm_near
err 'operand size not specified'
exit
call_rm_pword:
check @dest.jump_type & @dest.jump_type <> 'far'
jyes invalid_operand
xcall x86.select_operand_prefix@dest, (4)
call_rm_far:
xcall x86.store_instruction@dest, (0FFh),(11b)
exit
call_rm_dword:
check @dest.jump_type | @dest.type = 'reg'
jno call_rm_dword_auto
check @dest.jump_type = 'far'
jyes call_rm_dword_far
call_rm_dword_near:
xcall x86.select_operand_prefix@dest, (4)
jump call_rm_near
call_rm_dword_auto:
check x86.mode = 16
jno call_rm_dword_near
call_rm_dword_far:
xcall x86.select_operand_prefix@dest, (2)
jump call_rm_far
call_rm_word:
check @dest.jump_type & @dest.jump_type <> 'near'
jyes invalid_operand
xcall x86.select_operand_prefix@dest, (2)
call_rm_near:
xcall x86.store_instruction@dest, (0FFh),(10b)
exit
call_imm:
check @dest.jump_type & @dest.jump_type <> 'near'
jyes invalid_operand
check @dest.size = 2
jyes call_imm_word
check @dest.size = 4
jno invalid_operand
xcall x86.store_operand_prefix, (4)
emit 1, 0E8h
compute @dest.imm, @dest.imm-($+4)
asm dd @dest.imm
exit
call_imm_word:
xcall x86.store_operand_prefix, (2)
emit 1, 0E8h
compute @dest.imm, @dest.imm-($+2)
check @dest.imm relativeto 0
jno store_word
compute @dest.imm, @dest.imm and 0FFFFh
store_word:
asm dw @dest.imm
exit
end calminstruction
calminstruction jmp? dest*
call x86.parse_jump_operand@dest, dest
check @dest.type = 'imm'
jyes jmp_imm
check @dest.type = 'mem' | @dest.type = 'reg'
jyes jmp_rm
check @dest.type = 'far'
jyes jmp_direct_far
invalid_operand:
err 'invalid operand'
exit
jmp_direct_far:
check @dest.jump_type & @dest.jump_type <> 'far'
jyes invalid_operand
check @dest.size = 0
jyes prefix_ok
local size
compute size, @dest.size - 2
call x86.store_operand_prefix, size
prefix_ok:
check @dest.size and not 4 & @dest.size and not 6
jyes invalid_operand
emit 1, 0EAh
check (@dest.size = 0 & x86.mode = 16) | @dest.size = 4
jyes far_dword
asm dd @dest.offset
asm dw @dest.segment
exit
far_dword:
asm dw @dest.offset,@dest.segment
exit
jmp_rm:
check @dest.size = 6
jyes jmp_rm_pword
check @dest.size = 4
jyes jmp_rm_dword
check @dest.size = 2
jyes jmp_rm_word
check @dest.size
jyes invalid_operand
check @dest.jump_type = 'far'
jyes jmp_rm_far
check @dest.jump_type = 'near'
jyes jmp_rm_near
err 'operand size not specified'
exit
jmp_rm_pword:
check @dest.jump_type & @dest.jump_type <> 'far'
jyes invalid_operand
xcall x86.select_operand_prefix@dest, (4)
jmp_rm_far:
xcall x86.store_instruction@dest, (0FFh),(101b)
exit
jmp_rm_dword:
check @dest.jump_type | @dest.type = 'reg'
jno jmp_rm_dword_auto
check @dest.jump_type = 'far'
jyes jmp_rm_dword_far
jmp_rm_dword_near:
xcall x86.select_operand_prefix@dest, (4)
jump jmp_rm_near
jmp_rm_dword_auto:
check x86.mode = 16
jno jmp_rm_dword_near
jmp_rm_dword_far:
xcall x86.select_operand_prefix@dest, (2)
jump jmp_rm_far
jmp_rm_word:
check @dest.jump_type & @dest.jump_type <> 'near'
jyes invalid_operand
xcall x86.select_operand_prefix@dest, (2)
jmp_rm_near:
xcall x86.store_instruction@dest, (0FFh),(100b)
exit
jmp_imm:
call x86.store_operand_prefix, @dest.size
check @dest.jump_type = 'near'
jyes jmp_imm_near
check @dest.jump_type = 'short'
jyes jmp_imm_short_verify
check @dest.jump_type
jyes invalid_operand
check ~ $ relativeto 0 & @dest.imm relativeto 0
jno jmp_optimize
compute @dest.imm, @dest.imm + $ - 0 scaleof $
err 'invalid address'
jmp_optimize:
check @dest.unresolved
jyes jmp_imm_short
check @dest.imm relativeto $
jno jmp_imm_near
check (@dest.imm-($+2)) < 80h & (@dest.imm-($+2)) >= -80h
jyes jmp_imm_short
check (@dest.imm-($+2)) and (1 shl (@dest.size*8) - 1) < 80h | (@dest.imm-($+2)) and (1 shl (@dest.size*8) - 1) >= 1 shl (@dest.size*8) - 80h
jyes jmp_imm_short
jmp_imm_near:
check @dest.size = 2
jyes jmp_imm_word
check @dest.size = 4
jno invalid_operand
emit 1, 0E9h
compute @dest.imm, @dest.imm-($+4)
asm dd @dest.imm
exit
jmp_imm_word:
emit 1, 0E9h
compute @dest.imm, @dest.imm-($+2)
check @dest.imm relativeto 0
jno store_word
compute @dest.imm, @dest.imm and 0FFFFh
store_word:
asm dw @dest.imm
exit
jmp_imm_short_verify:
check (@dest.imm-($+2)) < 80h & (@dest.imm-($+2)) >= -80h
jyes jmp_imm_short
check (@dest.imm-($+2)) and (1 shl (@dest.size*8) - 1) < 80h | (@dest.imm-($+2)) and (1 shl (@dest.size*8) - 1) >= 1 shl (@dest.size*8) - 80h
jyes jmp_imm_short
emit 1, 0EBh
emit 1
jump relative_jump_out_of_range
jmp_imm_short:
emit 1, 0EBh
compute @dest.imm, (@dest.imm-($+1)) and 0FFh
emit 1, @dest.imm
exit
relative_jump_out_of_range:
err 'relative jump out of range'
exit
end calminstruction
iterate <instr,opcode>, jo,70h, jno,71h, jc,72h, jb,72h, jnae,72h, jnc,73h, jnb,73h, jae,73h, jz,74h, je,74h, jnz,75h, jne,75h, jna,76h, jbe,76h, ja,77h, jnbe,77h, \
js,78h, jns,79h, jp,7Ah, jpe,7Ah, jnp,7Bh, jpo,7Bh, jl,7Ch, jnge,7Ch, jnl,7Dh, jge,7Dh, jng,7Eh, jle,7Eh, jg,7Fh, jnle,7Fh
calminstruction instr? dest*
call x86.parse_jump_operand@dest, dest
check @dest.type <> 'imm' | @dest.jump_type = 'far'
jyes invalid_operand
call x86.store_operand_prefix, @dest.size
check ~ $ relativeto 0 & @dest.imm relativeto 0
jno optimize
compute @dest.imm, @dest.imm + $ - 0 scaleof $
err 'invalid address'
optimize:
check @dest.jump_type <> 'near' & ( @dest.unresolved | ( @dest.imm relativeto $ & @dest.imm-($+2) < 80h & @dest.imm-($+2) >= -80h ) )
jyes short
check @dest.jump_type <> 'near' & @dest.imm relativeto $ & ( (@dest.imm-($+2)) and (1 shl (@dest.size*8) - 1) < 80h | (@dest.imm-($+2)) and (1 shl (@dest.size*8) - 1) >= 1 shl (@dest.size*8) - 80h )
jyes short
check @dest.jump_type = 'short'
jyes relative_jump_out_of_range
emit 1, 0Fh
emit 1, 10h+opcode
check @dest.size = 2
jyes relative_word
compute @dest.imm, @dest.imm-($+4)
asm dd @dest.imm
exit
relative_word:
compute @dest.imm, @dest.imm-($+2)
check @dest.imm relativeto 0
jno store_word
compute @dest.imm, @dest.imm and 0FFFFh
store_word:
asm dw @dest.imm
exit
short:
compute @dest.imm, (@dest.imm-($+2)) and 0FFh
emit 1, opcode
emit 1, @dest.imm
exit
relative_jump_out_of_range:
emit 2
err 'relative jump out of range'
exit
invalid_operand:
err 'invalid operand'
exit
end calminstruction
end iterate
iterate <instr,opcode,len>, loopnz,0E0h,0, loopne,0E0h,0, loopz,0E1h,0, loope,0E1h,0, loop,0E2h,0, \
loopnzw,0E0h,2, loopnew,0E0h,2, loopzw,0E1h,2, loopew,0E1h,2, loopw,0E2h,2, \
loopnzd,0E0h,4, loopned,0E0h,4, loopzd,0E1h,4, looped,0E1h,4, loopd,0E2h,4, \
jcxz,0E3h,2, jecxz,0E3h,4
calminstruction instr? dest*
call x86.parse_jump_operand@dest, dest
check @dest.type = 'imm' & ( @dest.jump_type = 'short' | ~ @dest.jump_type )
jno invalid_operand
check len shl 3 and not x86.mode
jno address_prefix_ok
emit 1, 67h
address_prefix_ok:
check @dest.size shl 3 <> x86.mode
jno operand_prefix_ok
emit 1, 66h
operand_prefix_ok:
emit 1, opcode
check @dest.imm-($+1) < 80h & @dest.imm-($+1) >= -80h
jyes relative_offset_ok
check (@dest.imm-($+2)) and (1 shl (@dest.size*8) - 1) < 80h | (@dest.imm-($+2)) and (1 shl (@dest.size*8) - 1) >= 1 shl (@dest.size*8) - 80h
jyes relative_offset_ok
emit 1
err 'relative jump out of range'
exit
relative_offset_ok:
compute @dest.imm, (@dest.imm-($+1)) and 0FFh
emit 1, @dest.imm
exit
invalid_operand:
err 'invalid operand'
exit
end calminstruction
end iterate
iterate <instr,opcode>, daa,27h, das,2Fh, aaa,37h, aas,3Fh, nop,90h, int3,0CCh, into,0CEh, int1,0F1h, iret,0CFh, salc,0D6h, \
hlt,0F4h, cmc,0F5h, clc,0F8h, stc,0F9h, cli,0FAh, sti,0FBh, cld,0FCh, std,0FDh, \
pusha,60h, popa,61h, pushf,9Ch, popf,9Dh, sahf,9Eh, lahf,9Fh, leave,0C9h, \
insb,6Ch, outsb,6Eh, movsb,0A4h, cmpsb,0A6h, stosb,0AAh, lodsb,0ACh, scasb,0AEh, xlatb,0D7h, \
clts,<0Fh,06h>, loadall,<0Fh,07h>
match byte1=,byte2, opcode
calminstruction instr?
emit 1, byte1
emit 1, byte2
end calminstruction
else
calminstruction instr?
emit 1, opcode
end calminstruction
end match
end iterate
iterate <instr,opcode>, cbw,98h, cwd,99h, iretw,0CFh, pushaw,60h, popaw,61h, pushfw,9Ch, popfw,9Dh, \
insw,6Dh, outsw,6Fh, movsw,0A5h, cmpsw,0A7h, stosw,0ABh, lodsw,0ADh, scasw,0AFh
calminstruction instr?
xcall x86.store_operand_prefix, (2)
emit 1, opcode
end calminstruction
end iterate
iterate <instr,opcode>, cwde,98h, cdq,99h, iretd,0CFh, pushad,60h, popad,61h, pushfd,9Ch, popfd,9Ch, \
insd,6Dh, outsd,6Fh, movsd,0A5h, cmpsd,0A7h, stosd,0ABh, lodsd,0ADh, scasd,0AFh
calminstruction instr?
xcall x86.store_operand_prefix, (4)
emit 1, opcode
end calminstruction
end iterate
iterate <prefix,opcode>, lock,0F0h, repnz,0F2h, repne,0F2h, rep,0F3h, repz,0F3h, repe,0F3h
calminstruction prefix? instr&
emit 1, opcode
assemble instr
end calminstruction
end iterate
calminstruction int? number*
emit 1, 0CDh
emit 1, number
end calminstruction
calminstruction aam? number:10
emit 1, 0D4h
emit 1, number
end calminstruction
calminstruction aad? number:10
emit 1, 0D5h
emit 1, number
end calminstruction
if defined SSE2
purge movsd?, cmpsd?
end if
calminstruction movs? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
local size
check @dest.size = 0 & @src.size = 0
jyes operand_size_not_specified
check @dest.size <> 0 & @src.size <> 0 & @dest.size <> @src.size
jyes operand_sizes_do_not_match
compute size, @dest.size or @src.size
size_ok:
check @src.type = 'mem' & @src.mod = 0 & @dest.type = 'mem' & @dest.mod = 0 & ( (@src.mode = 16 & @src.rm = 4 & @dest.mode = 16 & @dest.rm = 5) | (@src.mode = 32 & @src.rm = 6 & @dest.mode = 32 & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h )
jno invalid_combination_of_operands
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh
jyes segment_prefix_ok
emit 1, @src.segment_prefix
segment_prefix_ok:
check @dest.mode = x86.mode
jyes address_prefix_ok
emit 1, 67h
address_prefix_ok:
check size > 1
jyes movs_word
emit 1, 0A4h
exit
movs_word:
call x86.store_operand_prefix, size
emit 1, 0A5h
exit
operand_size_not_specified:
err 'operand size not specified'
compute size, 0
jump size_ok
operand_sizes_do_not_match:
err 'operand sizes do not match'
compute size, 0
jump size_ok
invalid_combination_of_operands:
err 'invalid combination of operands'
exit
end calminstruction
calminstruction cmps? src*,dest*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
local size
check @dest.size = 0 & @src.size = 0
jyes operand_size_not_specified
check @dest.size <> 0 & @src.size <> 0 & @dest.size <> @src.size
jyes operand_sizes_do_not_match
compute size, @dest.size or @src.size
size_ok:
check @src.type = 'mem' & @src.mod = 0 & @dest.type = 'mem' & @dest.mod = 0 & ( (@src.mode = 16 & @src.rm = 4 & @dest.mode = 16 & @dest.rm = 5) | (@src.mode = 32 & @src.rm = 6 & @dest.mode = 32 & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h )
jno invalid_combination_of_operands
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh
jyes segment_prefix_ok
emit 1, @src.segment_prefix
segment_prefix_ok:
check @dest.mode = x86.mode
jyes address_prefix_ok
emit 1, 67h
address_prefix_ok:
check size > 1
jyes cmps_word
emit 1, 0A6h
exit
cmps_word:
call x86.store_operand_prefix, size
emit 1, 0A7h
exit
operand_size_not_specified:
err 'operand size not specified'
compute size, 0
jump size_ok
operand_sizes_do_not_match:
err 'operand sizes do not match'
compute size, 0
jump size_ok
invalid_combination_of_operands:
err 'invalid combination of operands'
exit
end calminstruction
calminstruction stos? dest*
call x86.parse_operand@dest, dest
check @dest.size
jyes size_ok
err 'operand size not specified'
size_ok:
check @dest.type = 'mem' & @dest.mod = 0 & ( (@dest.mode = 16 & @dest.rm = 5) | (@dest.mode = 32 & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h )
jno invalid_operand
check @dest.mode = x86.mode
jyes address_prefix_ok
emit 1, 67h
address_prefix_ok:
check @dest.size > 1
jyes stos_word
emit 1, 0AAh
exit
stos_word:
call x86.store_operand_prefix, @dest.size
emit 1, 0ABh
exit
invalid_operand:
err 'invalid operand'
exit
end calminstruction
calminstruction lods? src*
call x86.parse_operand@src, src
check @src.size
jyes size_ok
err 'operand size not specified'
size_ok:
check @src.type = 'mem' & @src.mod = 0 & ( (@src.mode = 16 & @src.rm = 4) | (@src.mode = 32 & @src.rm = 6) )
jno invalid_operand
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh
jyes segment_prefix_ok
emit 1, @src.segment_prefix
segment_prefix_ok:
check @src.mode = x86.mode
jyes address_prefix_ok
emit 1, 67h
address_prefix_ok:
check @src.size > 1
jyes lods_word
emit 1, 0ACh
exit
lods_word:
call x86.store_operand_prefix, @src.size
emit 1, 0ADh
exit
invalid_operand:
err 'invalid operand'
exit
end calminstruction
calminstruction scas? dest*
call x86.parse_operand@dest, dest
check @dest.size
jyes size_ok
err 'operand size not specified'
size_ok:
check @dest.type = 'mem' & @dest.mod = 0 & ( (@dest.mode = 16 & @dest.rm = 5) | (@dest.mode = 32 & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h )
jno invalid_operand
check @dest.mode = x86.mode
jyes address_prefix_ok
emit 1, 67h
address_prefix_ok:
check @dest.size > 1
jyes scas_word
emit 1, 0AEh
exit
scas_word:
call x86.store_operand_prefix, @dest.size
emit 1, 0AFh
exit
invalid_operand:
err 'invalid operand'
exit
end calminstruction
calminstruction ins? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @dest.size
jyes size_ok
err 'operand size not specified'
compute size, 0
size_ok:
check @src.type = 'reg' & @src.size = 2 & @src.rm = 2 & @dest.type = 'mem' & @dest.mod = 0 & ( (@dest.mode = 16 & @dest.rm = 5) | (@dest.mode = 32 & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h )
jno invalid_combination_of_operands
check @dest.mode = x86.mode
jyes address_prefix_ok
emit 1, 67h
address_prefix_ok:
check @dest.size > 1
jyes ins_word
emit 1, 6Ch
exit
ins_word:
call x86.store_operand_prefix, @dest.size
emit 1, 6Dh
exit
invalid_combination_of_operands:
err 'invalid combination of operands'
exit
end calminstruction
calminstruction outs? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @src.size
jyes size_ok
err 'operand size not specified'
size_ok:
check @dest.type = 'reg' & @dest.size = 2 & @dest.rm = 2 & @src.type = 'mem' & @src.mod = 0 & ( (@src.mode = 16 & @src.rm = 4) | (@src.mode = 32 & @src.rm = 6) )
jno invalid_combination_of_operands
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh
jyes segment_prefix_ok
emit 1, @src.segment_prefix
segment_prefix_ok:
check @src.mode = x86.mode
jyes address_prefix_ok
emit 1, 67h
address_prefix_ok:
check @src.size > 1
jyes outs_word
emit 1, 6Eh
exit
outs_word:
call x86.store_operand_prefix, @src.size
emit 1, 6Fh
exit
operand_size_not_specified:
err 'operand size not specified'
compute size, 0
jump size_ok
operand_sizes_do_not_match:
err 'operand sizes do not match'
compute size, 0
jump size_ok
invalid_combination_of_operands:
err 'invalid combination of operands'
exit
end calminstruction
calminstruction xlat? src*
call x86.parse_operand@src, src
check @src.size > 1
jno size_ok
err 'invalid operand size'
size_ok:
check @src.type = 'mem' & @src.mod = 0 & ( (@src.mode = 16 & @src.rm = 7) | (@src.mode = 32 & @src.rm = 3) )
jno invalid_operand
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh
jyes segment_prefix_ok
emit 1, @src.segment_prefix
segment_prefix_ok:
check @src.mode = x86.mode
jyes address_prefix_ok
emit 1, 67h
address_prefix_ok:
emit 1, 0D7h
exit
invalid_operand:
err 'invalid operand'
exit
end calminstruction
calminstruction in? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @dest.size
jyes size_ok
err 'operand size not specified'
size_ok:
check @src.type = 'reg' & @src.size = 2 & @src.rm = 2 & @dest.type = 'reg' & @dest.rm = 0
jyes in_ax_dx
check @src.type = 'imm' & @dest.type = 'reg' & @dest.rm = 0
jyes in_ax_imm
err 'invalid combination of operands'
exit
in_ax_dx:
check @dest.size > 1
jno in_al_dx
call x86.store_operand_prefix, @dest.size
emit 1, 0EDh
exit
in_al_dx:
emit 1, 0ECh
exit
in_ax_imm:
check @dest.size > 1
jno in_al_imm
call x86.store_operand_prefix, @dest.size
emit 1, 0E5h
emit 1, @src.imm
exit
in_al_imm:
emit 1, 0E4h
emit 1, @src.imm
exit
end calminstruction
calminstruction out? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @src.size
jyes size_ok
err 'operand size not specified'
size_ok:
check @dest.type = 'reg' & @dest.size = 2 & @dest.rm = 2 & @src.type = 'reg' & @src.rm = 0
jyes out_dx_ax
check @dest.type = 'imm' & @src.type = 'reg' & @src.rm = 0
jyes out_imm_ax
err 'invalid combination of operands'
exit
out_dx_ax:
check @src.size > 1
jno out_dx_al
call x86.store_operand_prefix, @src.size
emit 1, 0EFh
exit
out_dx_al:
emit 1, 0EEh
exit
out_imm_ax:
check @src.size > 1
jno out_imm_al
call x86.store_operand_prefix, @src.size
emit 1, 0E7h
emit 1, @dest.imm
exit
out_imm_al:
emit 1, 0E6h
emit 1, @dest.imm
exit
end calminstruction
calminstruction enter? alloc*,nesting*
call x86.parse_operand@src, alloc
call x86.parse_operand@aux, nesting
check (@src.size and not 2) | (@aux.size and not 1)
jno size_ok
err 'invalid operand size'
size_ok:
check @src.type = 'imm' & @aux.type = 'imm'
jyes operand_ok
err 'invalid operand'
exit
operand_ok:
emit 1, 0C8h
asm dw @src.imm
emit 1, @aux.imm
end calminstruction
calminstruction bound? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @src.type = 'mem' & @dest.type = 'reg'
jno invalid_combination_of_operands
check @src.size and not @dest.size
jno size_ok
err 'operand sizes do not match'
size_ok:
call x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, (62h),@dest.rm
exit
invalid_combination_of_operands:
err 'invalid combination of operands'
end calminstruction
calminstruction arpl? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @src.type = 'reg' & (@dest.type = 'mem' | @dest.type = 'reg')
jno invalid_combination_of_operands
check @src.size = 2
jno invalid_operand_size
check @dest.size and not @src.size
jno size_ok
err 'operand sizes do not match'
jump size_ok
invalid_operand_size:
err 'invalid operand size'
size_ok:
xcall x86.store_instruction@dest, (63h),@src.rm
exit
invalid_combination_of_operands:
err 'invalid combination of operands'
end calminstruction
iterate <instr,ext,postbyte>, lldt,0,2, ltr,0,3, verr,0,4, verw,0,5, lmsw,1,6
calminstruction instr? dest*
call x86.parse_operand@dest, dest
check @dest.size and not 2
jno size_ok
err 'invalid operand size'
size_ok:
check @dest.type = 'reg' | @dest.type = 'mem'
jyes operand_ok
err 'invalid operand'
exit
operand_ok:
xcall x86.store_instruction@dest, <0Fh,ext>,(postbyte)
end calminstruction
end iterate
iterate <instr,ext,postbyte>, sldt,0,0, str,0,1, smsw,1,4
calminstruction instr? dest*
call x86.parse_operand@dest, dest
check @dest.type = 'reg'
jyes select_operand_prefix
check @dest.size and not 2
jno size_ok
err 'invalid operand size'
size_ok:
check @dest.type = 'mem'
jyes store_instruction
err 'invalid combination of operands'
exit
select_operand_prefix:
call x86.select_operand_prefix@dest, @dest.size
store_instruction:
xcall x86.store_instruction@dest, <0Fh,ext>,(postbyte)
end calminstruction
end iterate
iterate <instr,postbyte>, lgdt,2, lidt,3, sgdt,0, sidt,1
calminstruction instr? dest*
call x86.parse_operand@dest, dest
check @dest.type = 'mem'
jyes operand_ok
err 'invalid operand'
exit
operand_ok:
check @dest.size = 6
jyes o32
check @dest.size = 5
jyes o16
check @dest.size
jno store_instruction
err 'invalid operand size'
jump store_instruction
o16:
xcall x86.select_operand_prefix@dest, (2)
jump store_instruction
o32:
xcall x86.select_operand_prefix@dest, (4)
store_instruction:
xcall x86.store_instruction@dest, <0Fh,1>,(postbyte)
end calminstruction
end iterate
iterate <instr,ext>, lar,2, lsl,3
calminstruction instr? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @dest.type = 'reg' & (@src.type = 'mem' | @src.type = 'reg')
jno invalid_combination_of_operands
check @src.size and not 2
jno size_ok
err 'invalid operand size'
size_ok:
call x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, <0Fh,ext>,@dest.rm
exit
invalid_combination_of_operands:
err 'invalid combination of operands'
end calminstruction
end iterate
calminstruction xbts? dest*,src*,offs*,len*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
call x86.parse_operand@src2, offs
call x86.parse_operand@aux, len
check @dest.type = 'reg' & (@src.type = 'mem' | @src.type = 'reg') & \
@src2.type = 'reg' & @src2.rm = 0 & @aux.type = 'reg' & @aux.size = 1 & @aux.rm = 1
jno invalid_combination_of_operands
check @src.size and not @dest.size | @src2.size <> @dest.size
jyes operand_sizes_no_not_match
check @dest.size > 1
jyes size_ok
err 'invalid operand size'
jump size_ok
operand_sizes_no_not_match:
err 'operand sizes do not match'
size_ok:
call x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, <0Fh,0A6h>,@dest.rm
exit
invalid_combination_of_operands:
err 'invalid combination of operands'
end calminstruction
calminstruction ibts? dest*,offs*,len*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
call x86.parse_operand@src2, offs
call x86.parse_operand@aux, len
check @src.type = 'reg' & (@dest.type = 'mem' | @dest.type = 'reg') & \
@src2.type = 'reg' & @src2.rm = 0 & @aux.type = 'reg' & @aux.size = 1 & @aux.rm = 1
jno invalid_combination_of_operands
check @dest.size and not @src.size | @src2.size <> @src.size
jyes operand_sizes_no_not_match
check @src.size > 1
jyes size_ok
err 'invalid operand size'
jump size_ok
operand_sizes_no_not_match:
err 'operand sizes do not match'
size_ok:
call x86.select_operand_prefix@dest, @src.size
xcall x86.store_instruction@dest, <0Fh,0A7h>,@src.rm
exit
invalid_combination_of_operands:
err 'invalid combination of operands'
end calminstruction
Reference in New Issue Copy Permalink