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/x64.inc

3477 lines
84 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 x86.r64 : x86.reg + 8
element al? : x86.r8 + 0
element cl? : x86.r8 + 1
element dl? : x86.r8 + 2
element bl? : x86.r8 + 3
element spl? : x86.r8 + 4
element bpl? : x86.r8 + 5
element sil? : x86.r8 + 6
element dil? : x86.r8 + 7
element ah? : x86.r8 - 4
element ch? : x86.r8 - 5
element dh? : x86.r8 - 6
element bh? : x86.r8 - 7
repeat 8, i:8
element r#i#b? : x86.r8 + i
element r#i#l? : x86.r8 + i
end repeat
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
repeat 8, i:8
element r#i#w? : x86.r16 + i
end repeat
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
repeat 8, i:8
element r#i#d? : x86.r32 + i
end repeat
element rax? : x86.r64 + 0
element rcx? : x86.r64 + 1
element rdx? : x86.r64 + 2
element rbx? : x86.r64 + 3
element rsp? : x86.r64 + 4
element rbp? : x86.r64 + 5
element rsi? : x86.r64 + 6
element rdi? : x86.r64 + 7
repeat 8, i:8
element r#i? : x86.r64 + i
end repeat
element x86.ip
element eip? : x86.ip + 4
element rip? : x86.ip + 8
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
repeat 16, i:0
element cr#i? : x86.crx + i
element dr#i? : x86.drx + 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
define x86.tword? :10
define x86.tbyte? :10
define x86.dqword? :16
x86.mode = 16
macro use16?
x86.mode = 16
end macro
macro use32?
x86.mode = 32
end macro
macro use64?
x86.mode = 64
end macro
x86.REX_REQUIRED = 100h
x86.REX_FORBIDDEN = 200h
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, rex_prefix, \
imm, unresolved, displacement, displacement_size, auto_relative, \
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 rex_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
check rm < 0
jyes register_precluding_rex
check size = 1 & rm >= 4 & rm < 8
jyes register_requiring_rex
exit
register_precluding_rex:
compute rm, x86.REX_FORBIDDEN - rm
exit
register_requiring_rex:
compute rm, x86.REX_REQUIRED + rm
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 | i metadataof address relativeto x86.r64 | i metadataof address relativeto x86.ip
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
compute auto_relative, 0
check address_registers eq 0
jyes direct_address
check mode & mode <> 0 scaleof (1 metadataof (1 metadataof address_registers)) shl 3 & ~ 1 metadataof address_registers relativeto x86.ip
jyes invalid_address
check 1 metadataof address_registers relativeto x86.r64 | 1 metadataof address_registers relativeto x86.r32
jyes address_32bit_64bit
check 1 metadataof address_registers relativeto x86.r16
jyes address_16bit
check address_registers eq rip | address_registers eq eip
jyes rip_relative_address
jump invalid_address
rip_relative_address:
compute mode, 0 scaleof (1 metadataof address_registers) shl 3
compute mod, 0
compute rm, 5
compute displacement_size, 4
exit
direct_address:
compute mod, 0
check x86.mode = 64
jyes direct_address_in_long_mode
check mode = 0
jno mode_ok
compute mode, x86.mode
check mode = 16 & displacement relativeto 0 & displacement >= 10000h
jno mode_ok
compute mode, 32
mode_ok:
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
direct_address_in_long_mode:
compute displacement_size, 4
check mode = 0 & segment_prefix < 64h
jyes auto_relative_address
check mode = 16
jyes invalid_address_size
compute rm, 4
compute base, 5
compute index, 4
compute scale, 1
check mode = 32
jno direct_address_displacement_ready
check ~ displacement relativeto 0 | displacement >= 100000000h | displacement < -100000000h
jyes address_out_of_range
compute displacement, displacement and 0FFFFFFFFh
direct_address_displacement_ready:
check displacement relativeto 0 & displacement > 7FFFFFFFh & displacement < 100000000h
jyes direct_address_switch_to_32bit
compute mode, 64
compute displacement_size, 8
exit
direct_address_switch_to_32bit:
compute mode, 32
exit
auto_relative_address:
compute mode, 64
compute rm, 5
compute auto_relative, 1
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_64bit:
local address_registers_type
check 1 metadataof address_registers relativeto x86.r64
jyes address_64bit
address_32bit:
compute mode, 32
compute address_registers_type, x86.r32
jump check_address_registers
address_64bit:
compute mode, 64
compute address_registers_type, x86.r64
check_address_registers:
check 2 scaleof address_registers = 0
jyes one_register
check 3 scaleof address_registers = 0 & 2 metadataof address_registers relativeto address_registers_type
jyes two_registers
jump invalid_address
one_register:
compute scale, 1 scaleof address_registers
compute base, 1 metadataof address_registers - address_registers_type
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:
check base and 111b = 4
jyes one_register_unscaled_in_sib
compute rm, base
jump setup_displacement
one_register_unscaled_in_sib:
compute rm, 4
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 - address_registers_type
compute index, 2 metadataof address_registers - address_registers_type
compute scale, 2 scaleof address_registers
jump process_sib
base_second:
compute base, 2 metadataof address_registers - address_registers_type
compute index, 1 metadataof address_registers - address_registers_type
compute scale, 1 scaleof address_registers
process_sib:
check index = 4
jyes forbidden_index
check (x86.mode <> 64 & segment_prefix = 36h) & index = 5 & scale = 1
jyes switch_to_index
check (x86.mode = 64 | 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 and 111b <> 5 & (rm <> 4 | base and 111b <> 5)
jyes displacement_empty
check displacement < 80h & displacement >= -80h
jyes displacement_8bit
check displacement - 1 shl mode >= -80h & displacement < 1 shl mode
jyes displacement_8bit_wrap
check (x86.mode = 64 | 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:
compute displacement, displacement - 1 shl mode
jump displacement_8bit
index_only:
compute displacement_size, 4
compute mod, 0
exit
far_operand:
compute type, 'far'
check size & size <> 4 & size <> 6 & size <> 10
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
address_out_of_range:
err 'address out of range'
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 <> 16) | (size = 4 & x86.mode = 16)
jyes prefix_66h
check size = 8
jyes prefix_48h
check size <> 0 & size <> 2 & size <> 4
jyes invalid_size
exit
prefix_66h:
compute prefix, 66h
exit
prefix_48h:
compute prefix, 48h
exit
invalid_size:
err 'invalid operand size'
end calminstruction
calminstruction x86.store_instruction#context opcode*,reg*,imm_size:0,immediate
check segment_prefix
jno segment_prefix_ok
check mode = 64
jyes segment_in_long_mode
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
jump store_segment_prefix
segment_in_long_mode:
check segment_prefix < 64h
jyes segment_prefix_ok
store_segment_prefix:
emit 1, segment_prefix
segment_prefix_ok:
check mod <> 11b & mode <> x86.mode
jno addressing_prefix_ok
check mode = 64 | (mode = 16 & x86.mode = 64)
jno store_addressing_prefix
err 'illegal addressing mode'
store_addressing_prefix:
emit 1, 67h
addressing_prefix_ok:
check (reg or rm) and x86.REX_REQUIRED
jno rex_1
compute rex_prefix, rex_prefix or 40h
rex_1:
check rm and 1000b | (mod <> 11b & mode > 16 & rm = 4 & base and 1000b)
jno rex_2
compute rex_prefix, rex_prefix or 41h
rex_2:
check mod <> 11b & mode > 16 & rm = 4 & index and 1000b
jno rex_4
compute rex_prefix, rex_prefix or 42h
rex_4:
check reg and 1000b
jno rex_8
compute rex_prefix, rex_prefix or 44h
rex_8:
check prefix = 48h
jno operand_prefix
compute rex_prefix, rex_prefix or 48h
jump operand_prefix_ok
operand_prefix:
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:
check rex_prefix
jno rex_prefix_ok
check x86.mode < 64
jyes instruction_requires_long_mode
check reg and x86.REX_FORBIDDEN
jno store_rex_prefix
err 'disallowed combination of registers'
jump store_rex_prefix
instruction_requires_long_mode:
err 'instruction requires long mode'
store_rex_prefix:
emit 1, rex_prefix
rex_prefix_ok:
asm db opcode
emit 1, mod shl 6 + (reg and 111b) shl 3 + rm and 111b
check mod <> 11b & rm = 4 & mode <> 16
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 | displacement_size = 8
jno displacement_ok
compute displacement, displacement
check auto_relative
jno auto_relative_ok
check imm_size < 8
jyes adjust_auto_relative_displacement
compute displacement, displacement - ($ + 4 + 4)
jump auto_relative_ok
adjust_auto_relative_displacement:
compute displacement, displacement - ($ + 4 + imm_size)
auto_relative_ok:
check mode = 64 & displacement relativeto 0
jno displacement_ready
check displacement - 1 shl 64 >= -80000000h & displacement < 1 shl 64
jyes adjust_displacement_wrap
check displacement >= -80000000h & displacement < 80000000h
jyes displacement_ready
err 'address value out of signed range'
adjust_displacement_wrap:
compute displacement, displacement - 1 shl 64
displacement_ready:
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
jyes immediate_32bit
check imm_size = 8
jno immediate_ok
call x86.simm32, immediate
jump 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
immediate_ok:
end calminstruction
end namespace
end iterate
calminstruction x86.store_operand_prefix size*, reg:0
local rex_prefix
compute rex_prefix, 0
check (size = 2 & x86.mode <> 16) | (size = 4 & x86.mode = 16)
jyes prefix_66h
check size = 8
jyes rex_8
check size <> 0 & size <> 2 & size <> 4
jno check_register
err 'invalid operand size'
jump check_register
prefix_66h:
emit 1, 66h
jump check_register
rex_8:
compute rex_prefix, 48h
check_register:
check reg and 1000b
jyes rex_1
check reg and x86.REX_REQUIRED
jno rex_ready
compute rex_prefix, rex_prefix or 40h
jump rex_ready
rex_1:
compute rex_prefix, rex_prefix or 41h
rex_ready:
check rex_prefix
jno rex_prefix_ok
check x86.mode < 64
jyes instruction_requires_long_mode
check reg and x86.REX_FORBIDDEN
jno store_rex_prefix
err 'disallowed combination of registers'
jump store_rex_prefix
instruction_requires_long_mode:
err 'instruction requires long mode'
store_rex_prefix:
emit 1, rex_prefix
rex_prefix_ok:
end calminstruction
calminstruction x86.simm32 immediate*
compute immediate, +immediate
check immediate eqtype 0.0
jno check_value
asm virtual at 0
asm emit 8: immediate
asm load immediate:8 from 0
asm end virtual
compute immediate, +immediate
check_value:
check immediate relativeto 0
jyes check_range
asm dd immediate
exit
check_range:
check immediate - 1 shl 64 >= -80000000h & immediate < 1 shl 64
jyes wrap
check immediate >= 80000000h | immediate < -80000000h
jyes out_of_range
emit 4, immediate
exit
wrap:
emit 4, immediate - 1 shl 64
exit
out_of_range:
err 'immediate value out of signed range'
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 @src.imm relativeto 0 & @src.imm - 1 shl (size shl 3) >= -80h & @src.imm < 1 shl (size shl 3)
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
check size = 8
jyes simm32
asm emit size: @src.imm
exit
imm32:
asm dd @src.imm
exit
simm32:
call x86.simm32, @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 & \
~ @dest.auto_relative & ( @dest.displacement_size <> 8 | ~ @dest.displacement relativeto 0 | @dest.displacement and 0FFFFFFFF80000000h <> 0FFFFFFFF80000000h)
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 & \
~ @src.auto_relative & ( @src.displacement_size <> 8 | ~ @src.displacement relativeto 0 | @src.displacement and 0FFFFFFFF80000000h <> 0FFFFFFFF80000000h)
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 x86.mode = 64
jyes mov_dirmem_ax_longmode
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
check @dest.displacement_size = 8
jyes dest_displacement_64bit
asm dd @dest.address
exit
dest_displacement_16bit:
asm dw @dest.address
exit
dest_displacement_64bit:
asm dq @dest.address
exit
mov_dirmem_ax_longmode:
check @dest.displacement_size = 8 & @dest.displacement relativeto 0 & @dest.displacement >= 0 & @dest.displacement < 100000000h
jno dest_displacement_size_ok
compute @dest.displacement_size, 4
dest_displacement_size_ok:
check @dest.segment_prefix & @dest.segment_prefix >= 64h
jno dest_longmode_seg_ok
emit 1, @dest.segment_prefix
dest_longmode_seg_ok:
check @dest.mode = 16
jyes illegal_addressing_mode
check @dest.displacement_size = 8
jyes dest_addr_size_ok
emit 1, 67h
jump dest_addr_size_ok
mov_ax_dirmem:
check x86.mode = 64
jyes mov_ax_dirmem_longmode
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
check @src.displacement_size = 8
jyes src_displacement_64bit
asm dd @src.address
exit
src_displacement_16bit:
asm dw @src.address
exit
src_displacement_64bit:
asm dq @src.address
exit
mov_ax_dirmem_longmode:
check @src.displacement_size = 8 & @src.displacement relativeto 0 & @src.displacement >= 0 & @src.displacement < 100000000h
jno src_displacement_size_ok
compute @src.displacement_size, 4
src_displacement_size_ok:
check @src.segment_prefix & @src.segment_prefix >= 64h
jno src_longmode_seg_ok
emit 1, @src.segment_prefix
src_longmode_seg_ok:
check @src.mode = 16
jyes illegal_addressing_mode
check @src.displacement_size = 8
jyes src_addr_size_ok
emit 1, 67h
jump src_addr_size_ok
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
check @src.imm eqtype 0.0
jno mov_reg_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
mov_reg_imm_optimize:
check size = 8 & @src.imm relativeto 0 & @src.imm < 80000000h & @src.imm >= -80000000h
jyes mov_reg_simm
check size = 8 & @src.imm relativeto 0 & @src.imm - 1 shl 64 < 80000000h & @src.imm - 1 shl 64 >= -80000000h
jyes mov_reg_simm_wrap
call x86.store_operand_prefix, size,@dest.rm
emit 1, 0B8h + @dest.rm and 111b
check size = 2
jyes src_imm_16bit
check size = 4
jyes src_imm_32bit
asm dq @src.imm
exit
src_imm_32bit:
asm dd @src.imm
exit
src_imm_16bit:
asm dw @src.imm
exit
mov_reg_imm_8bit:
xcall x86.store_operand_prefix, (0),@dest.rm
emit 1, 0B0h + @dest.rm and 111b
emit 1, @src.imm
exit
mov_reg_simm_wrap:
compute @src.imm, @src.imm - 1 shl 64
mov_reg_simm:
call x86.select_operand_prefix@dest, size
xcall x86.store_instruction@dest, (0C7h),(0),size,@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 (x86.mode <> 64 & @dest.size = 4) | (x86.mode = 64 & @dest.size = 8)
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 (x86.mode <> 64 & @src.size = 4) | (x86.mode = 64 & @src.size = 8)
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
illegal_addressing_mode:
err 'illegal addressing mode'
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
check size = 4
jyes src_imm_32bit
call x86.simm32, @src.imm
exit
src_imm_16bit:
asm dw @src.imm
exit
src_imm_32bit:
asm dd @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 & @dest.rm) | (size = 4 & @src.rm or @dest.rm = 0)
jyes xchg_rm_reg
check size > 1
jno xchg_rm_reg_8bit
compute @src.rm, @src.rm or @dest.rm
call x86.store_operand_prefix, size,@src.rm
emit 1, 90h + @src.rm and 111b
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,0 ,dec,1
calminstruction instr? dest*
call x86.parse_operand@dest, dest
check @dest.size
jyes main
err 'operand size not specified'
main:
check @dest.type = 'mem' | (x86.mode = 64 & @dest.type = 'reg')
jyes inc_rm
check @dest.type = 'reg'
jyes inc_reg
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 + postbyte shl 3
exit
inc_rm:
check @dest.size > 1
jno inc_rm_8bit
xcall 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
xcall 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 @aux.imm relativeto 0 & @aux.imm - 1 shl (size shl 3) >= -80h & @aux.imm < 1 shl (size shl 3)
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 & x86.mode < 64) | (size = 8 & x86.mode = 64)
jyes main
invalid_operand_size:
err 'invalid operand size'
main:
check (x86.mode <> 16 & size = 2) | (x86.mode = 16 & size = 4)
jno prefix_ready
compute @src.prefix, 66h
prefix_ready:
check @src.type = 'mem'
jyes push_mem
check @src.prefix
jno prefix_stored
emit 1, @src.prefix
prefix_stored:
check @src.type = 'reg'
jyes push_reg
check @src.type = 'sreg'
jyes push_sreg
check @src.type = 'imm'
jyes push_imm
invalid_operand:
err 'invalid operand'
exit
push_mem:
xcall x86.store_instruction@src, (0FFh),(110b)
exit
push_reg:
check @src.rm and 1000b
jyes push_new_reg
emit 1, 50h + @src.rm
exit
push_new_reg:
emit 1, 41h
emit 1, 50h + @src.rm and 111b
exit
push_sreg:
check @src.rm >= 4
jyes push_sreg_386
check x86.mode = 64
jyes invalid_operand
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
check x86.mode = 32
jyes push_imm_32bit
compute size, 8
jump push_imm_size_ok
push_imm_32bit:
compute size, 4
jump push_imm_size_ok
push_imm_16bit:
compute size, 2
push_imm_size_ok:
check @src.imm eqtype 0.0
jno push_imm_check
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_check:
check size = 8 & @src.imm relativeto 0
jno push_imm_optimize
check @src.imm - 10000000000000000h >= -80000000h & @src.imm < 10000000000000000h
jyes push_imm_wrap
check @src.imm >= 80000000h | @src.imm < -80000000h
jyes out_of_signed_range
jump push_imm_optimize
push_imm_wrap:
compute @src.imm, @src.imm - 10000000000000000h
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
out_of_signed_range:
err 'immediate value out of signed range'
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 & x86.mode < 64) | (size = 8 & x86.mode = 64)
jyes main
invalid_operand_size:
err 'invalid operand size'
main:
check (x86.mode <> 16 & size = 2) | (x86.mode = 16 & size = 4)
jno prefix_ready
compute @dest.prefix, 66h
prefix_ready:
check @dest.type = 'mem'
jyes pop_mem
check @dest.prefix
jno prefix_stored
emit 1, @dest.prefix
prefix_stored:
check @dest.type = 'reg'
jyes pop_reg
check @dest.type = 'sreg'
jyes pop_sreg
invalid_operand:
err 'invalid operand'
exit
pop_mem:
xcall x86.store_instruction@dest, (8Fh),(0)
exit
pop_reg:
check @dest.rm and 1000b
jyes pop_new_reg
emit 1, 58h + @dest.rm
exit
pop_new_reg:
emit 1, 41h
emit 1, 58h + @dest.rm and 111b
exit
pop_sreg:
check @dest.rm = 1
jyes invalid_operand
check @dest.rm >= 4
jyes pop_sreg_386
check x86.mode = 64
jyes invalid_operand
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,r8w,r9w,r10w,r11w,r12w,r13w,r14w,r15w, \
eax,ecx,edx,ebx,esp,ebp,esi,edi,r8d,r9d,r10d,r11d,r12d,r13d,r14d,r15d, \
rax,rcx,rdx,rbx,rsp,rbp,rsi,rdi,r8,r9,r10,r11,r12,r13,r14,r15, \
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, pushq,push_instruction,8, \
pop,pop_instruction,0, popw,pop_instruction,2, popd,pop_instruction,4, popq,pop_instruction,8
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
check x86.mode < 64
jyes illegal_instruction
xcall x86.store_operand_prefix, (size)
match , operand
jyes ret_short
emit 1, opcode
asm dw operand
exit
ret_short:
emit 1, opcode + 1
exit
illegal_instruction:
err 'illegal instruction'
end calminstruction
end iterate
iterate <instr,opcode>, retq,0C2h, retnq,0C2h, retfq,0CAh
calminstruction instr? operand
check x86.mode = 64
jno instruction_requires_long_mode
match , operand
jyes ret_short
emit 1, opcode
asm dw operand
exit
ret_short:
emit 1, opcode + 1
exit
instruction_requires_long_mode:
err 'instruction requires long mode'
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
xcall 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
calminstruction instr? dest*,src*
check x86.mode = 64
jyes illegal_instruction
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
xcall x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, (opcode),@dest.rm
exit
illegal_instruction:
err 'illegal instruction'
exit
invalid_operand_size:
err 'invalid operand size'
exit
invalid_combination_of_operands:
err 'invalid combination of operands'
end calminstruction
end iterate
iterate <instr,opcode>, 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)) | (@dest.size = 8 & (@src.size <> 0 & @src.size <> 10))
jyes invalid_operand_size
check @src.type = 'mem' & @dest.type = 'reg'
jno invalid_combination_of_operands
xcall x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, <opcode>,@dest.rm
exit
invalid_operand_size:
err 'invalid operand size'
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
xcall 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
xcall 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:
xcall x86.select_operand_prefix@dest, @src.size
xcall x86.store_instruction@dest, <0Fh,ext+1>,@src.rm
exit
shld_imm:
xcall 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
xcall 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 operand_size_not_specified
xcall x86.select_operand_prefix@dest, @dest.size
xcall x86.store_instruction@dest, <0Fh,0BAh>,(postbyte),byte,@src.imm
exit
operand_size_not_specified:
err 'operand size not specified'
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_rm_reg
err 'invalid combination of operands'
exit
bsf_rm_reg:
check @src.size and not @dest.size
jno bsf_rm_reg_ok
err 'operand sizes do not match'
bsf_rm_reg_ok:
xcall 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:
xcall x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, <0Fh,ext+1>,@dest.rm
exit
movzx_byte:
xcall 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
calminstruction movsxd? 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 and not 4
jyes invalid_operand_size
xcall x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, (63h),@dest.rm
exit
invalid_operand_size:
err 'invalid operand size'
end calminstruction
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
calminstruction cmov#cond? 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 cmov_rm_reg
err 'invalid combination of operands'
exit
cmov_rm_reg:
check @src.size and not @dest.size
jno cmov_rm_reg_ok
err 'operand sizes do not match'
cmov_rm_reg_ok:
xcall x86.select_operand_prefix@src, @dest.size
xcall x86.store_instruction@src, <0Fh,40h+code>,@dest.rm
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
illegal_instruction:
err 'illegal instruction'
exit
call_direct_far:
check @dest.jump_type & @dest.jump_type <> 'far'
jyes invalid_operand
check x86.mode = 64
jyes illegal_instruction
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 | @dest.size = 10
jyes call_rm_pword
check @dest.size = 8 & x86.mode = 64
jyes call_rm_qword
check @dest.size = 4 & x86.mode < 64
jyes call_rm_dword
check @dest.size = 2 & x86.mode < 64
jyes call_rm_word
check @dest.size
jyes invalid_operand
check x86.mode = 64
jno rex_prefix_ok
compute @dest.prefix, 48h
rex_prefix_ok:
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
local size
compute size, @dest.size - 2
call x86.select_operand_prefix@dest, size
call_rm_far:
xcall x86.store_instruction@dest, (0FFh),(11b)
exit
call_rm_qword:
check @dest.jump_type & @dest.jump_type <> 'near'
jyes invalid_operand
jump call_rm_near
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 = 8 & x86.mode = 64
jyes call_imm_qword
check @dest.size = 2 & x86.mode < 64
jyes call_imm_word
check @dest.size = 4 & x86.mode < 64
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
call_imm_qword:
emit 1, 0E8h
compute @dest.imm, @dest.imm-($+4)
check @dest.imm relativeto 0 & (@dest.imm < -80000000h | @dest.imm >= 80000000h)
jno store_dword
err 'relative jump out of range'
store_dword:
asm dd @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
illegal_instruction:
err 'illegal instruction'
exit
jmp_direct_far:
check @dest.jump_type & @dest.jump_type <> 'far'
jyes invalid_operand
check x86.mode = 64
jyes illegal_instruction
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 | @dest.size = 10
jyes jmp_rm_pword
check @dest.size = 8 & x86.mode = 64
jyes jmp_rm_qword
check @dest.size = 4 & x86.mode < 64
jyes jmp_rm_dword
check @dest.size = 2 & x86.mode < 64
jyes jmp_rm_word
check @dest.size
jyes invalid_operand
check x86.mode = 64
jno rex_prefix_ok
compute @dest.prefix, 48h
rex_prefix_ok:
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
local size
compute size, @dest.size - 2
call x86.select_operand_prefix@dest, size
jmp_rm_far:
xcall x86.store_instruction@dest, (0FFh),(101b)
exit
jmp_rm_qword:
check @dest.jump_type & @dest.jump_type <> 'near'
jyes invalid_operand
jump jmp_rm_near
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:
check @dest.jump_type = 'far'
jyes invalid_operand
check (@dest.size = 8 & x86.mode < 64) | (@dest.size < 8 & x86.mode = 64)
jyes invalid_operand
check @dest.size = 8
jyes jmp_imm_prefix_ok
call x86.store_operand_prefix, @dest.size
jmp_imm_prefix_ok:
check @dest.jump_type = 'short'
jyes jmp_imm_short_verify
check @dest.jump_type = 'near'
jyes jmp_imm_near
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 = 8
jyes jmp_imm_qword
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_qword:
emit 1, 0E9h
compute @dest.imm, @dest.imm-($+4)
asm dd @dest.imm
check @dest.imm relativeto 0 & (@dest.imm < -80000000h | @dest.imm >= 80000000h)
jyes relative_jump_out_of_range
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
relative_jump_out_of_range:
err 'relative jump out of range'
exit
jmp_imm_short:
emit 1, 0EBh
compute @dest.imm, (@dest.imm-($+1)) and 0FFh
emit 1, @dest.imm
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
check x86.mode = 64 | @dest.size = 8
jyes long
call x86.store_operand_prefix, @dest.size
jump prefix_ok
long:
check x86.mode < 64 | @dest.size <> 8
jyes invalid_operand
prefix_ok:
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, \
loopnzq,0E0h,8, loopneq,0E0h,8, loopzq,0E1h,8, loopeq,0E1h,8, loopq,0E2h,8, \
jcxz,0E3h,2, jecxz,0E3h,4, jrcxz,0E3h,8
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
check len = 8 | (len = 2 & x86.mode = 64)
jyes illegal_instruction
emit 1, 67h
address_prefix_ok:
check @dest.size shl 3 <> x86.mode
jno operand_prefix_ok
check @dest.size = 8 | x86.mode = 64
jyes invalid_operand
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
illegal_instruction:
err 'illegal instruction'
exit
invalid_operand:
err 'invalid operand'
exit
end calminstruction
end iterate
iterate <instr,opcode>, nop,90h, int3,0CCh, into,0CEh, int1,0F1h, salc,0D6h, \
hlt,0F4h, cmc,0F5h, clc,0F8h, stc,0F9h, cli,0FAh, sti,0FBh, cld,0FCh, std,0FDh, \
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,6>, invd,<0Fh,8>, wbinvd,<0Fh,9>, wrmsr,<0Fh,30h>, rdtsc,<0Fh,31h>, rdmsr,<0Fh,32h>, rdpmc,<0Fh,33h>, \
sysenter,<0Fh,34h>, sysexit,<0Fh,35h>, cpuid,<0Fh,0A2h>, rsm,<0Fh,0AAh>
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, \
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, \
insd,6Dh, outsd,6Fh, stosd,0ABh, lodsd,0ADh, scasd,0AFh
calminstruction instr?
xcall x86.store_operand_prefix, (4)
emit 1, opcode
end calminstruction
end iterate
iterate <instr,opcode>, cdqe,98h, cqo,99h, iretq,0CFh, \
movsq,0A5h, cmpsq,0A7h, stosq,0ABh, lodsq,0ADh, scasq,0AFh, \
sysretq,<0Fh,7>, wrmsrq,<0Fh,30h>, rdmsrq,<0Fh,32h>, sysexitq,<0Fh,35h>
match byte1=,byte2, opcode
calminstruction instr?
xcall x86.store_operand_prefix, (8)
emit 1, byte1
emit 1, byte2
end calminstruction
else
calminstruction instr?
xcall x86.store_operand_prefix, (8)
emit 1, opcode
end calminstruction
end match
end iterate
iterate <instr,opcode>, swapgs,<0Fh,1,0F8h>, syscall,<0Fh,5>, sysret,<0Fh,7>
calminstruction instr?
check x86.mode = 64
jyes ok
err 'instruction requires long mode'
exit
ok:
asm db 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 iret?
check x86.mode < 64
jyes prefix_ok
emit 1, 48h
prefix_ok:
emit 1, 0CFh
end calminstruction
iterate <instr,opcode>, daa,27h, das,2Fh, aaa,37h, aas,3Fh, pusha,60h, popa,61h
calminstruction instr?
check x86.mode < 64
jyes allowed
err 'illegal instruction'
exit
allowed:
emit 1, opcode
end calminstruction
end iterate
calminstruction aam? number:10
check x86.mode < 64
jyes allowed
err 'illegal instruction'
exit
allowed:
emit 1, 0D4h
emit 1, number
end calminstruction
calminstruction aad? number:10
check x86.mode < 64
jyes allowed
err 'illegal instruction'
exit
allowed:
emit 1, 0D5h
emit 1, number
end calminstruction
iterate <instr,opcode>, pushaw,60h, popaw,61h, pushfw,9Ch, popfw,9Dh
calminstruction instr?
check x86.mode < 64
jyes allowed
err 'illegal instruction'
exit
allowed:
xcall x86.store_operand_prefix, (2)
emit 1, opcode
end calminstruction
end iterate
iterate <instr,opcode>, pushad,60h, popad,61h, pushfd,9Ch, popfd,9Dh
calminstruction instr?
check x86.mode < 64
jyes allowed
err 'illegal instruction'
exit
allowed:
xcall x86.store_operand_prefix, (4)
emit 1, opcode
end calminstruction
end iterate
iterate <instr,opcode>, pushfq,9Ch, popfq,9Dh
calminstruction instr?
check x86.mode = 64
jyes allowed
err 'instruction requires long mode'
exit
allowed:
emit 1, opcode
end calminstruction
end iterate
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 & ( (x86.mode < 64 & @src.mode = 16 & @src.rm = 4 & @dest.mode = 16 & @dest.rm = 5) | (@src.mode > 16 & @src.rm = 6 & @dest.mode = @src.mode & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h | (x86.mode = 64 & @dest.segment_prefix < 64h))
jno invalid_combination_of_operands
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh | (x86.mode = 64 & @src.segment_prefix < 64h)
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 & ( (x86.mode < 64 & @src.mode = 16 & @src.rm = 4 & @dest.mode = 16 & @dest.rm = 5) | (@src.mode > 16 & @src.rm = 6 & @dest.mode = @src.mode & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h | (x86.mode = 64 & @dest.segment_prefix < 64h))
jno invalid_combination_of_operands
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh | (x86.mode = 64 & @src.segment_prefix < 64h)
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 & ( (x86.mode < 64 & @dest.mode = 16 & @dest.rm = 5) | (@dest.mode > 16 & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h | (x86.mode = 64 & @dest.segment_prefix < 64h))
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 & ( (x86.mode < 64 & @src.mode = 16 & @src.rm = 4) | (@src.mode > 16 & @src.rm = 6) )
jno invalid_operand
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh | (x86.mode = 64 & @src.segment_prefix < 64h)
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 & ( (x86.mode < 64 & @dest.mode = 16 & @dest.rm = 5) | (@dest.mode > 16 & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h | (x86.mode = 64 & @dest.segment_prefix < 64h))
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 & ( (x86.mode < 64 & @dest.mode = 16 & @dest.rm = 5) | (@dest.mode > 16 & @dest.rm = 7) ) & ( @dest.segment_prefix = 0 | @dest.segment_prefix = 26h | (x86.mode = 64 & @dest.segment_prefix < 64h))
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 & ( (x86.mode < 64 & @src.mode = 16 & @src.rm = 4) | (@src.mode > 16 & @src.rm = 6) )
jno invalid_combination_of_operands
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh | (x86.mode = 64 & @src.segment_prefix < 64h)
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 & ( (x86.mode < 64 & @src.mode = 16 & @src.rm = 7) | (@src.mode > 16 & @src.rm = 3) )
jno invalid_operand
check @src.segment_prefix = 0 | @src.segment_prefix = 3Eh | (x86.mode = 64 & @src.segment_prefix < 64h)
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 = 8
jyes invalid_size
check @dest.size
jyes size_ok
err 'operand size not specified'
jump size_ok
invalid_size:
err 'invalid_operand_size'
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 = 8
jyes invalid_size
check @src.size
jyes size_ok
err 'operand size not specified'
jump size_ok
invalid_size:
err 'invalid_operand_size'
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*
check x86.mode < 64
jyes allowed
err 'illegal instruction'
exit
allowed:
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:
xcall 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'
exit
end calminstruction
calminstruction arpl? dest*,src*
check x86.mode < 64
jyes allowed
err 'illegal instruction'
exit
allowed:
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'
exit
exit
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:
xcall 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 x86.mode = 64 & @dest.size = 10
jyes store_instruction
check x86.mode < 64 & @dest.size = 6
jyes o32
check x86.mode < 64 & @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:
xcall 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
iterate <instr,ext>, cmpxchg,0B0h, xadd,0C0h
calminstruction instr? dest*,src*
call x86.parse_operand@dest, dest
call x86.parse_operand@src, src
check @src.type = 'reg' & ( @dest.type = 'reg' | @dest.type = 'mem' )
jyes xadd_rm_reg
err 'invalid combination of operands'
exit
xadd_rm_reg:
check @dest.size and not @src.size
jno size_ok
err 'operand sizes do not match'
size_ok:
check @src.size > 1
jno xadd_rm_reg_8bit
xcall x86.select_operand_prefix@dest, @src.size
xcall x86.store_instruction@dest, <0Fh,ext+1>,@src.rm
exit
xadd_rm_reg_8bit:
xcall x86.store_instruction@dest, <0Fh,ext>,@src.rm
end calminstruction
end iterate
calminstruction cmpxchg8b? dest*
call x86.parse_operand@dest, dest
check @dest.type = 'mem'
jyes operand_ok
err 'invalid operand'
exit
operand_ok:
check @dest.size and not 8
jno size_ok
err 'invalid operand size'
size_ok:
xcall x86.store_instruction@dest, <0Fh,0C7h>,(1)
end calminstruction
calminstruction cmpxchg16b? dest*
call x86.parse_operand@dest, dest
check @dest.type = 'mem'
jyes operand_ok
err 'invalid operand'
exit
operand_ok:
check @dest.size and not 16
jno size_ok
err 'invalid operand size'
size_ok:
xcall x86.store_operand_prefix, (8)
xcall x86.store_instruction@dest, <0Fh,0C7h>,(1)
end calminstruction
calminstruction bswap? dest*
call x86.parse_operand@dest, dest
check @dest.type = 'reg' & @dest.size > 2
jyes operand_ok
err 'invalid operand'
exit
operand_ok:
call x86.store_operand_prefix, @dest.size,@dest.rm
emit 1, 0Fh
emit 1, 0C8h + @dest.rm and 111b
end calminstruction
calminstruction invlpg? dest*
call x86.parse_operand@dest, dest
check @dest.type = 'mem'
jyes operand_ok
err 'invalid operand'
exit
operand_ok:
xcall x86.store_instruction@dest, <0Fh,1>,(7)
end calminstruction
include '80387.inc'
iterate <instr,opcode,postbyte>, fcmovb,0DAh,0C0h, fcmove,0DAh,0C8h, fcmovbe,0DAh,0D0h, fcmovu,0DAh,0D8h, \
fcmovnb,0DBh,0C0h, fcmovne,0DBh,0C8h, fcmovnbe,0DBh,0D0h, fcmovnu,0DBh,0D8h
calminstruction instr? dest*,src*
call x87.parse_operand@dest, dest
call x87.parse_operand@src, src
check @dest.type = 'streg' & @dest.rm = 0 & @src.type = 'streg'
jyes ok
err 'invalid operand'
exit
ok:
emit 1, opcode
emit 1, postbyte + @src.rm
end calminstruction
end iterate
iterate <instr,opcode,postbyte>, fucomi,0DBh,5, fucomip,0DFh,5, fcomi,0DBh,6, fcomip,0DFh,6
calminstruction instr? src:st1
call x87.parse_operand@src, src
check @src.type = 'streg'
jyes ok
err 'invalid operand'
exit
ok:
emit 1, opcode
emit 1, 11b shl 6 + postbyte shl 3 + @src.rm
end calminstruction
end iterate
include 'ext/sse2.inc'
repeat 8, i:8
element xmm#i? : SSE.reg + i
end repeat
iterate <instr,postbyte>, fxsave64,0, fxrstor64,1
calminstruction instr? src*
check x86.mode = 64
jyes allowed
err 'instruction requires long mode'
exit
allowed:
call x86.parse_operand@src, src
check @src.type = 'mem'
jno invalid_operand
check @src.size and not 512
jno size_ok
err 'invalid operand size'
size_ok:
xcall x86.select_operand_prefix@src, (8)
xcall x86.store_instruction@src, <0Fh,0AEh>,(postbyte)
exit
invalid_operand:
err 'invalid operand'
end calminstruction
end iterate
Reference in New Issue Copy Permalink