; flat assembler core
; Copyright (c) 1999-2016, Tomasz Grysztar.
; All rights reserved.
avx_single_source_pd_instruction_er_evex:
or [vex_required],8
avx_single_source_pd_instruction_er:
or [operand_flags],2+4+8
jmp avx_pd_instruction
avx_single_source_pd_instruction_sae_evex:
or [vex_required],8
or [operand_flags],2+4
jmp avx_pd_instruction
avx_pd_instruction_imm8:
mov [immediate_size],1
jmp avx_pd_instruction
avx_pd_instruction_er:
or [operand_flags],8
avx_pd_instruction_sae:
or [operand_flags],4
avx_pd_instruction:
mov [opcode_prefix],66h
or [rex_prefix],80h
mov cx,0800h
jmp avx_instruction_with_broadcast
avx_pd_instruction_38_evex:
or [vex_required],8
mov [supplemental_code],al
mov al,38h
jmp avx_pd_instruction
avx_cvtps2dq_instruction:
mov [opcode_prefix],66h
jmp avx_single_source_ps_instruction_er
avx_cvtudq2ps_instruction:
mov [opcode_prefix],0F2h
avx_single_source_ps_instruction_er_evex:
or [vex_required],8
avx_single_source_ps_instruction_er:
or [operand_flags],2+4+8
jmp avx_ps_instruction
avx_single_source_ps_instruction_noevex:
or [operand_flags],2
or [vex_required],2
jmp avx_ps_instruction
avx_ps_instruction_imm8:
mov [immediate_size],1
jmp avx_ps_instruction
avx_ps_instruction_er:
or [operand_flags],8
avx_ps_instruction_sae:
or [operand_flags],4
avx_ps_instruction:
mov cx,0400h
jmp avx_instruction_with_broadcast
avx_ps_instruction_66_38_evex:
or [vex_required],8
mov [opcode_prefix],66h
mov [supplemental_code],al
mov al,38h
jmp avx_ps_instruction
avx_sd_instruction_er:
or [operand_flags],8
avx_sd_instruction_sae:
or [operand_flags],4
avx_sd_instruction:
mov [opcode_prefix],0F2h
or [rex_prefix],80h
mov cl,8
jmp avx_instruction
avx_ss_instruction_er:
or [operand_flags],8
avx_ss_instruction_sae:
or [operand_flags],4
avx_ss_instruction:
mov [opcode_prefix],0F3h
mov cl,4
jmp avx_instruction
avx_ss_instruction_noevex:
or [vex_required],2
jmp avx_ss_instruction
avx_single_source_q_instruction_38_evex:
or [operand_flags],2
avx_q_instruction_38_evex:
or [vex_required],8
avx_q_instruction_38:
mov [supplemental_code],al
mov al,38h
jmp avx_q_instruction
avx_q_instruction_38_w1_evex:
or [vex_required],8
avx_q_instruction_38_w1:
or [rex_prefix],8
jmp avx_q_instruction_38
avx_q_instruction_3a_imm8_evex:
mov [immediate_size],1
or [vex_required],8
mov [supplemental_code],al
mov al,3Ah
jmp avx_q_instruction
avx_q_instruction_evex:
or [vex_required],8
avx_q_instruction:
or [rex_prefix],80h
mov ch,8
jmp avx_pi_instruction
avx_single_source_d_instruction_38_evex:
or [vex_required],8
avx_single_source_d_instruction_38:
or [operand_flags],2
jmp avx_d_instruction_38
avx_d_instruction_38_evex:
or [vex_required],8
avx_d_instruction_38:
mov [supplemental_code],al
mov al,38h
jmp avx_d_instruction
avx_d_instruction_3a_imm8_evex:
mov [immediate_size],1
or [vex_required],8
mov [supplemental_code],al
mov al,3Ah
jmp avx_d_instruction
avx_single_source_d_instruction_imm8:
or [operand_flags],2
mov [immediate_size],1
jmp avx_d_instruction
avx_d_instruction_evex:
or [vex_required],8
avx_d_instruction:
mov ch,4
jmp avx_pi_instruction
avx_single_source_bw_instruction_38:
or [operand_flags],2
avx_bw_instruction_38:
mov [supplemental_code],al
mov al,38h
avx_bw_instruction:
xor ch,ch
avx_pi_instruction:
mov [opcode_prefix],66h
xor cl,cl
jmp avx_instruction_with_broadcast
avx_bw_instruction_38_w1_evex:
or [rex_prefix],8
avx_bw_instruction_38_evex:
or [vex_required],8
jmp avx_bw_instruction_38
avx_pd_instruction_noevex:
xor cl,cl
or [vex_required],2
mov [opcode_prefix],66h
jmp avx_instruction
avx_ps_instruction_noevex:
or [vex_required],2
mov [opcode_prefix],0F2h
xor cl,cl
jmp avx_instruction
avx_instruction:
xor ch,ch
avx_instruction_with_broadcast:
mov [mmx_size],cl
mov [broadcast_size],ch
mov [base_code],0Fh
mov [extended_code],al
avx_xop_common:
or [vex_required],1
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
avx_reg:
lods byte [esi]
call convert_avx_register
mov [postbyte_register],al
call take_avx512_mask
avx_vex_reg:
test [operand_flags],2
jnz avx_vex_reg_ok
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [vex_register],al
avx_vex_reg_ok:
mov al,[mmx_size]
or al,al
jz avx_regs_size_ok
mov ah,[operand_size]
or ah,ah
jz avx_regs_size_ok
cmp al,ah
je avx_regs_size_ok
ja invalid_operand_size
cmp ah,16
jne invalid_operand_size
avx_regs_size_ok:
lods byte [esi]
cmp al,','
jne invalid_operand
avx_regs_rm:
call take_avx_rm
jc avx_regs_reg
mov al,[immediate_size]
cmp al,1
je mmx_imm8
jb instruction_ready
cmp al,-4
je sse_cmp_mem_ok
cmp byte [esi],','
jne invalid_operand
inc esi
call take_avx_register
shl al,4
jc invalid_operand
or byte [value],al
test al,80h
jz avx_regs_mem_reg_store
cmp [code_type],64
jne invalid_operand
avx_regs_mem_reg_store:
call take_imm4_if_needed
call store_instruction_with_imm8
jmp instruction_assembled
avx_regs_reg:
mov bl,al
call take_avx512_rounding
mov al,[immediate_size]
cmp al,1
je mmx_nomem_imm8
jb nomem_instruction_ready
cmp al,-4
je sse_cmp_nomem_ok
lods byte [esi]
cmp al,','
jne invalid_operand
mov al,bl
shl al,4
jc invalid_operand
or byte [value],al
test al,80h
jz avx_regs_reg_
cmp [code_type],64
jne invalid_operand
avx_regs_reg_:
call take_avx_rm
jc avx_regs_reg_reg
cmp [immediate_size],-2
jg invalid_operand
or [rex_prefix],8
call take_imm4_if_needed
call store_instruction_with_imm8
jmp instruction_assembled
avx_regs_reg_reg:
shl al,4
jc invalid_operand
and byte [value],1111b
or byte [value],al
call take_imm4_if_needed
call store_nomem_instruction
mov al,byte [value]
stos byte [edi]
jmp instruction_assembled
take_avx_rm:
xor cl,cl
xchg cl,[operand_size]
lods byte [esi]
call get_size_operator
cmp al,'['
je take_avx_mem
cmp al,10h
jne invalid_operand
mov [operand_size],cl
lods byte [esi]
call convert_avx_register
or cl,cl
jnz avx_reg_ok
or cl,[mmx_size]
jz avx_reg_ok
cmp ah,cl
je avx_reg_ok
jb invalid_operand_size
cmp ah,16
jne invalid_operand_size
avx_reg_ok:
stc
ret
take_avx_mem:
push ecx
call get_address
cmp byte [esi],'{'
jne avx_mem_ok
inc esi
lods byte [esi]
cmp al,1Fh
jne invalid_operand
mov al,[esi]
shr al,4
cmp al,1
jne invalid_operand
mov al,[mmx_size]
or al,al
jnz avx_mem_broadcast_check
mov eax,[esp]
or al,al
jnz avx_mem_broadcast_check
mov al,[broadcast_size]
mov [mmx_size],al
mov ah,cl
lods byte [esi]
and al,1111b
mov cl,al
mov al,[broadcast_size]
shl al,cl
mov [esp],al
mov cl,ah
jmp avx_mem_broadcast_ok
avx_mem_broadcast_check:
bsf eax,eax
xchg al,[broadcast_size]
mov [mmx_size],al
bsf eax,eax
jz invalid_operand
mov ah,[broadcast_size]
sub ah,al
lods byte [esi]
and al,1111b
cmp al,ah
jne invalid_operand_size
avx_mem_broadcast_ok:
or [vex_required],40h
lods byte [esi]
cmp al,'}'
jne invalid_operand
avx_mem_ok:
pop eax
or al,al
jz avx_mem_size_deciding
xchg al,[operand_size]
cmp [mmx_size],0
jne avx_mem_size_enforced
or al,al
jz avx_mem_size_ok
cmp al,[operand_size]
jne operand_sizes_do_not_match
avx_mem_size_ok:
clc
ret
avx_mem_size_deciding:
mov al,[operand_size]
cmp [mmx_size],0
jne avx_mem_size_enforced
cmp al,16
je avx_mem_size_ok
cmp al,32
je avx_mem_size_ok
cmp al,64
je avx_mem_size_ok
or al,al
jnz invalid_operand_size
call recoverable_unknown_size
avx_mem_size_enforced:
or al,al
jz avx_mem_size_ok
cmp al,[mmx_size]
je avx_mem_size_ok
jmp invalid_operand_size
take_imm4_if_needed:
cmp [immediate_size],-3
jne imm4_ok
push ebx ecx edx
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
cmp al,'('
jne invalid_operand
call get_byte_value
test al,11110000b
jnz value_out_of_range
or byte [value],al
pop edx ecx ebx
imm4_ok:
ret
take_avx512_mask:
cmp byte [esi],'{'
jne avx512_masking_ok
test [operand_flags],10h
jnz invalid_operand
inc esi
lods byte [esi]
cmp al,14h
jne invalid_operand
lods byte [esi]
mov ah,al
shr ah,4
cmp ah,5
jne invalid_operand
or al,al
jz invalid_operand
and al,111b
mov [mask_register],al
or [vex_required],20h
lods byte [esi]
cmp al,'}'
jne invalid_operand
cmp byte [esi],'{'
jne avx512_masking_ok
test [operand_flags],20h
jnz invalid_operand
inc esi
lods byte [esi]
cmp al,1Fh
jne invalid_operand
lods byte [esi]
or al,al
jnz invalid_operand
or [mask_register],80h
lods byte [esi]
cmp al,'}'
jne invalid_operand
avx512_masking_ok:
retn
take_avx512_rounding:
test [operand_flags],4+8
jz avx512_rounding_done
cmp [mmx_size],0
jne avx512_rounding_allowed
cmp [operand_size],64
jne avx512_rounding_done
avx512_rounding_allowed:
cmp byte [esi],','
jne avx512_rounding_done
cmp byte [esi+1],'{'
jne avx512_rounding_done
add esi,2
mov [rounding_mode],0
or [vex_required],40h+80h
test [operand_flags],8
jz take_sae
lods byte [esi]
cmp al,1Fh
jne invalid_operand
lods byte [esi]
mov ah,al
shr ah,4
cmp ah,2
jne invalid_operand
and al,11b
mov [rounding_mode],al
lods byte [esi]
cmp al,'-'
jne invalid_operand
take_sae:
lods byte [esi]
cmp al,1Fh
jne invalid_operand
lods byte [esi]
cmp al,30h
jne invalid_operand
lods byte [esi]
cmp al,'}'
jne invalid_operand
avx512_rounding_done:
retn
avx_movdqu_instruction:
mov ah,0F3h
jmp avx_movdq_instruction
avx_movdqa_instruction:
mov ah,66h
avx_movdq_instruction:
mov [opcode_prefix],ah
or [vex_required],2
jmp avx_movps_instruction
avx512_movdqu16_instruction:
or [rex_prefix],8
avx512_movdqu8_instruction:
mov ah,0F2h
jmp avx_movdq_instruction_evex
avx512_movdqu64_instruction:
or [rex_prefix],8
avx512_movdqu32_instruction:
mov ah,0F3h
jmp avx_movdq_instruction_evex
avx512_movdqa64_instruction:
or [rex_prefix],8
avx512_movdqa32_instruction:
mov ah,66h
avx_movdq_instruction_evex:
mov [opcode_prefix],ah
or [vex_required],8
jmp avx_movps_instruction
avx_movpd_instruction:
mov [opcode_prefix],66h
or [rex_prefix],80h
avx_movps_instruction:
or [operand_flags],2
mov [base_code],0Fh
mov [extended_code],al
or [vex_required],1
xor al,al
mov [mmx_size],al
mov [broadcast_size],al
lods byte [esi]
call get_size_operator
cmp al,10h
je avx_reg
inc [extended_code]
test [extended_code],1
jnz avx_mem
add [extended_code],-1+10h
avx_mem:
cmp al,'['
jne invalid_operand
call get_address
or [operand_flags],20h
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [postbyte_register],al
jmp instruction_ready
avx_movntpd_instruction:
or [rex_prefix],80h
avx_movntdq_instruction:
mov [opcode_prefix],66h
avx_movntps_instruction:
mov [base_code],0Fh
mov [extended_code],al
or [vex_required],1
or [operand_flags],10h
mov [mmx_size],0
lods byte [esi]
call get_size_operator
jmp avx_mem
avx_compress_q_instruction:
or [rex_prefix],8
avx_compress_d_instruction:
or [vex_required],8
mov [mmx_size],0
call setup_66_0f_38
lods byte [esi]
call get_size_operator
cmp al,10h
jne avx_mem
lods byte [esi]
call convert_avx_register
mov bl,al
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [postbyte_register],al
jmp nomem_instruction_ready
avx_lddqu_instruction:
mov ah,0F2h
or [vex_required],2
avx_load_instruction:
mov [opcode_prefix],ah
mov [base_code],0Fh
mov [extended_code],al
mov [mmx_size],0
or [vex_required],1
call take_avx_register
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,'['
jne invalid_operand
call get_address
jmp instruction_ready
avx_movntdqa_instruction:
mov [supplemental_code],al
mov al,38h
mov ah,66h
jmp avx_load_instruction
avx_movq_instruction:
or [rex_prefix],8
mov [mmx_size],8
jmp avx_mov_instruction
avx_movd_instruction:
mov [mmx_size],4
avx_mov_instruction:
or [vex_required],1
mov [opcode_prefix],66h
mov [base_code],0Fh
mov [extended_code],7Eh
lods byte [esi]
call get_size_operator
cmp al,10h
je avx_movd_reg
cmp al,'['
jne invalid_operand
call get_address
mov al,[mmx_size]
not al
and [operand_size],al
jnz invalid_operand_size
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_avx_register
cmp ah,16
jne invalid_operand_size
mov [postbyte_register],al
cmp [mmx_size],8
jne instruction_ready
and [rex_prefix],not 8
or [rex_prefix],80h
mov [extended_code],0D6h
jmp instruction_ready
avx_movd_reg:
lods byte [esi]
cmp al,0C0h
jae avx_movd_xmmreg
call convert_register
cmp ah,[mmx_size]
jne invalid_operand_size
mov [operand_size],0
mov bl,al
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_avx_register
cmp ah,16
jne invalid_operand_size
mov [postbyte_register],al
jmp nomem_instruction_ready
avx_movd_xmmreg:
sub [extended_code],10h
call convert_avx_register
cmp ah,16
jne invalid_operand_size
mov [postbyte_register],al
mov [operand_size],0
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
je avx_movd_xmmreg_reg
cmp al,'['
jne invalid_operand
call get_address
mov al,[mmx_size]
cmp al,8
jne avx_movd_xmmreg_mem_ready
call avx_movq_xmmreg_xmmreg_opcode
avx_movd_xmmreg_mem_ready:
not al
test [operand_size],al
jnz invalid_operand_size
jmp instruction_ready
avx_movd_xmmreg_reg:
lods byte [esi]
cmp al,0C0h
jae avx_movq_xmmreg_xmmreg
call convert_register
cmp ah,[mmx_size]
jne invalid_operand_size
mov bl,al
jmp nomem_instruction_ready
avx_movq_xmmreg_xmmreg:
cmp [mmx_size],8
jne invalid_operand
call avx_movq_xmmreg_xmmreg_opcode
call convert_avx_register
cmp ah,16
jne invalid_operand_size
mov bl,al
jmp nomem_instruction_ready
avx_movq_xmmreg_xmmreg_opcode:
and [rex_prefix],not 8
or [rex_prefix],80h
add [extended_code],10h
mov [opcode_prefix],0F3h
ret
avx_movddup_instruction:
or [vex_required],1
mov [opcode_prefix],0F2h
mov [base_code],0Fh
mov [extended_code],al
or [rex_prefix],80h
xor al,al
mov [mmx_size],al
mov [broadcast_size],al
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_avx_register
mov [postbyte_register],al
cmp ah,16
ja avx_movddup_size_ok
mov [mmx_size],8
avx_movddup_size_ok:
call take_avx512_mask
jmp avx_vex_reg_ok
avx_movlpd_instruction:
mov [opcode_prefix],66h
or [rex_prefix],80h
avx_movlps_instruction:
mov [base_code],0Fh
mov [extended_code],al
mov [mmx_size],8
mov [broadcast_size],0
or [vex_required],1
lods byte [esi]
call get_size_operator
cmp al,10h
jne avx_movlps_mem
lods byte [esi]
call convert_avx_register
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [vex_register],al
cmp [operand_size],16
jne invalid_operand
mov [operand_size],0
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_rm
jc invalid_operand
jmp instruction_ready
avx_movlps_mem:
cmp al,'['
jne invalid_operand
call get_address
avx_movlps_mem_:
mov al,[operand_size]
or al,al
jz avx_movlps_mem_size_ok
cmp al,[mmx_size]
jne invalid_operand_size
mov [operand_size],0
avx_movlps_mem_size_ok:
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
cmp ah,16
jne invalid_operand
mov [postbyte_register],al
inc [extended_code]
jmp instruction_ready
avx_movhlps_instruction:
mov [base_code],0Fh
mov [extended_code],al
or [vex_required],1
call take_avx_register
cmp ah,16
jne invalid_operand
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [vex_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov bl,al
jmp nomem_instruction_ready
avx_movsd_instruction:
mov al,0F2h
mov cl,8
or [rex_prefix],80h
jmp avx_movs_instruction
avx_movss_instruction:
mov al,0F3h
mov cl,4
avx_movs_instruction:
mov [opcode_prefix],al
mov [mmx_size],cl
or [vex_required],1
mov [base_code],0Fh
mov [extended_code],10h
lods byte [esi]
call get_size_operator
cmp al,10h
jne avx_movs_mem
lods byte [esi]
call convert_avx_register
cmp ah,16
jne invalid_operand
mov [postbyte_register],al
call take_avx512_mask
xor cl,cl
xchg cl,[operand_size]
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
jne avx_movs_reg_mem
mov [operand_size],cl
lods byte [esi]
call convert_avx_register
mov [vex_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov bl,al
cmp bl,8
jb nomem_instruction_ready
inc [extended_code]
xchg bl,[postbyte_register]
jmp nomem_instruction_ready
avx_movs_reg_mem:
cmp al,'['
jne invalid_operand
call get_address
mov al,[operand_size]
or al,al
jz avx_movs_reg_mem_ok
cmp al,[mmx_size]
jne invalid_operand_size
avx_movs_reg_mem_ok:
jmp instruction_ready
avx_movs_mem:
cmp al,'['
jne invalid_operand
call get_address
or [operand_flags],20h
call take_avx512_mask
jmp avx_movlps_mem_
avx_comiss_instruction:
or [operand_flags],2+4+10h
mov cl,4
jmp avx_instruction
avx_comisd_instruction:
or [operand_flags],2+4+10h
mov [opcode_prefix],66h
or [rex_prefix],80h
mov cl,8
jmp avx_instruction
avx_movshdup_instruction:
or [operand_flags],2
mov [opcode_prefix],0F3h
xor cl,cl
jmp avx_instruction
avx_cvtqq2pd_instruction:
mov [opcode_prefix],0F3h
or [vex_required],8
or [operand_flags],2+4+8
or [rex_prefix],8
mov cx,0800h
jmp avx_instruction_with_broadcast
avx_pshuf_w_instruction:
mov [opcode_prefix],al
or [operand_flags],2
mov [immediate_size],1
mov al,70h
xor cl,cl
jmp avx_instruction
avx_single_source_128bit_instruction_38_noevex:
or [operand_flags],2
avx_128bit_instruction_38_noevex:
mov cl,16
jmp avx_instruction_38_noevex
avx_single_source_instruction_38_noevex:
or [operand_flags],2
jmp avx_pi_instruction_38_noevex
avx_pi_instruction_38_noevex:
xor cl,cl
avx_instruction_38_noevex:
or [vex_required],2
avx_instruction_38:
mov [opcode_prefix],66h
mov [supplemental_code],al
mov al,38h
jmp avx_instruction
avx_ss_instruction_3a_imm8_noevex:
mov cl,4
jmp avx_instruction_3a_imm8_noevex
avx_sd_instruction_3a_imm8_noevex:
mov cl,8
jmp avx_instruction_3a_imm8_noevex
avx_single_source_128bit_instruction_3a_imm8_noevex:
or [operand_flags],2
avx_128bit_instruction_3a_imm8_noevex:
mov cl,16
jmp avx_instruction_3a_imm8_noevex
avx_triple_source_instruction_3a_noevex:
xor cl,cl
mov [immediate_size],-1
mov byte [value],0
jmp avx_instruction_3a_noevex
avx_single_source_instruction_3a_imm8_noevex:
or [operand_flags],2
avx_pi_instruction_3a_imm8_noevex:
xor cl,cl
avx_instruction_3a_imm8_noevex:
mov [immediate_size],1
avx_instruction_3a_noevex:
or [vex_required],2
avx_instruction_3a:
mov [opcode_prefix],66h
mov [supplemental_code],al
mov al,3Ah
jmp avx_instruction
avx_pi_instruction_3a_imm8:
xor cl,cl
mov [immediate_size],1
jmp avx_instruction_3a
avx_pclmulqdq_instruction:
mov byte [value],al
mov [immediate_size],-4
or [vex_required],2
mov cl,16
mov al,44h
jmp avx_instruction_3a
avx512_single_source_pd_instruction_sae_imm8:
or [operand_flags],2
avx512_pd_instruction_sae_imm8:
or [rex_prefix],8
mov cx,0800h
jmp avx512_instruction_sae_imm8
avx512_single_source_ps_instruction_sae_imm8:
or [operand_flags],2
avx512_ps_instruction_sae_imm8:
mov cx,0400h
jmp avx512_instruction_sae_imm8
avx512_sd_instruction_sae_imm8:
or [rex_prefix],8
mov cx,0008h
jmp avx512_instruction_sae_imm8
avx512_ss_instruction_sae_imm8:
mov cx,0004h
avx512_instruction_sae_imm8:
or [operand_flags],4
avx512_instruction_imm8:
or [vex_required],8
mov [opcode_prefix],66h
mov [immediate_size],1
mov [supplemental_code],al
mov al,3Ah
jmp avx_instruction_with_broadcast
avx512_pd_instruction_er:
or [operand_flags],4+8
jmp avx512_pd_instruction
avx512_single_source_pd_instruction_sae:
or [operand_flags],4
avx512_single_source_pd_instruction:
or [operand_flags],2
avx512_pd_instruction:
or [rex_prefix],8
mov cx,0800h
jmp avx512_instruction
avx512_ps_instruction_er:
or [operand_flags],4+8
jmp avx512_ps_instruction
avx512_single_source_ps_instruction_sae:
or [operand_flags],4
avx512_single_source_ps_instruction:
or [operand_flags],2
avx512_ps_instruction:
mov cx,0400h
jmp avx512_instruction
avx512_sd_instruction_er:
or [operand_flags],8
avx512_sd_instruction_sae:
or [operand_flags],4
avx512_sd_instruction:
or [rex_prefix],8
mov cx,0008h
jmp avx512_instruction
avx512_ss_instruction_er:
or [operand_flags],8
avx512_ss_instruction_sae:
or [operand_flags],4
avx512_ss_instruction:
mov cx,0004h
avx512_instruction:
or [vex_required],8
mov [opcode_prefix],66h
mov [supplemental_code],al
mov al,38h
jmp avx_instruction_with_broadcast
avx512_exp2pd_instruction:
or [rex_prefix],8
or [operand_flags],2+4
mov cx,0840h
jmp avx512_instruction
avx512_exp2ps_instruction:
or [operand_flags],2+4
mov cx,0440h
jmp avx512_instruction
fma_instruction_pd:
or [rex_prefix],8
mov cx,0800h
jmp fma_instruction
fma_instruction_ps:
mov cx,0400h
jmp fma_instruction
fma_instruction_sd:
or [rex_prefix],8
mov cx,0008h
jmp fma_instruction
fma_instruction_ss:
mov cx,0004h
fma_instruction:
or [operand_flags],4+8
mov [opcode_prefix],66h
mov [supplemental_code],al
mov al,38h
jmp avx_instruction_with_broadcast
fma4_instruction_p:
xor cl,cl
jmp fma4_instruction
fma4_instruction_sd:
mov cl,8
jmp fma4_instruction
fma4_instruction_ss:
mov cl,4
fma4_instruction:
mov [immediate_size],-2
mov byte [value],0
jmp avx_instruction_3a_noevex
avx_cmp_pd_instruction:
mov [opcode_prefix],66h
or [rex_prefix],80h
mov cx,0800h
jmp avx_cmp_instruction
avx_cmp_ps_instruction:
mov cx,0400h
jmp avx_cmp_instruction
avx_cmp_sd_instruction:
mov [opcode_prefix],0F2h
or [rex_prefix],80h
mov cx,0008h
jmp avx_cmp_instruction
avx_cmp_ss_instruction:
mov [opcode_prefix],0F3h
mov cx,0004h
avx_cmp_instruction:
mov byte [value],al
mov [immediate_size],-4
or [operand_flags],4+20h
mov al,0C2h
jmp avx_cmp_common
avx_cmpeqq_instruction:
or [rex_prefix],80h
mov ch,8
mov [supplemental_code],al
mov al,38h
jmp avx_cmp_pi_instruction
avx_cmpeqd_instruction:
mov ch,4
jmp avx_cmp_pi_instruction
avx_cmpeqb_instruction:
xor ch,ch
jmp avx_cmp_pi_instruction
avx512_cmp_uq_instruction:
or [rex_prefix],8
mov ch,8
mov ah,1Eh
jmp avx_cmp_pi_instruction_evex
avx512_cmp_ud_instruction:
mov ch,4
mov ah,1Eh
jmp avx_cmp_pi_instruction_evex
avx512_cmp_q_instruction:
or [rex_prefix],8
mov ch,8
mov ah,1Fh
jmp avx_cmp_pi_instruction_evex
avx512_cmp_d_instruction:
mov ch,4
mov ah,1Fh
jmp avx_cmp_pi_instruction_evex
avx512_cmp_uw_instruction:
or [rex_prefix],8
avx512_cmp_ub_instruction:
xor ch,ch
mov ah,3Eh
jmp avx_cmp_pi_instruction_evex
avx512_cmp_w_instruction:
or [rex_prefix],8
avx512_cmp_b_instruction:
xor ch,ch
mov ah,3Fh
avx_cmp_pi_instruction_evex:
mov byte [value],al
mov [immediate_size],-4
mov [supplemental_code],ah
mov al,3Ah
or [vex_required],8
avx_cmp_pi_instruction:
xor cl,cl
or [operand_flags],20h
mov [opcode_prefix],66h
avx_cmp_common:
mov [mmx_size],cl
mov [broadcast_size],ch
mov [extended_code],al
mov [base_code],0Fh
lods byte [esi]
call get_size_operator
cmp al,14h
je avx_maskreg
cmp al,10h
jne invalid_operand
or [vex_required],2
jmp avx_reg
avx_maskreg:
cmp [operand_size],0
jne invalid_operand_size
or [vex_required],8
lods byte [esi]
call convert_mask_register
mov [postbyte_register],al
call take_avx512_mask
jmp avx_vex_reg
avx512_fpclasspd_instruction:
or [rex_prefix],8
mov cx,0800h
jmp avx_fpclass_instruction
avx512_fpclassps_instruction:
mov cx,0400h
jmp avx_fpclass_instruction
avx512_fpclasssd_instruction:
or [rex_prefix],8
mov cx,0008h
jmp avx_fpclass_instruction
avx512_fpclassss_instruction:
mov cx,0004h
avx_fpclass_instruction:
mov [broadcast_size],ch
mov [mmx_size],cl
or [operand_flags],2
call setup_66_0f_3a
mov [immediate_size],1
lods byte [esi]
cmp al,14h
je avx_maskreg
jmp invalid_operand
avx512_ptestnmd_instruction:
mov ch,4
jmp avx512_ptestnm_instruction
avx512_ptestnmq_instruction:
or [rex_prefix],8
mov ch,8
jmp avx512_ptestnm_instruction
avx512_ptestnmw_instruction:
or [rex_prefix],8
avx512_ptestnmb_instruction:
xor ch,ch
avx512_ptestnm_instruction:
mov ah,0F3h
jmp avx512_ptest_instruction
avx512_ptestmd_instruction:
mov ch,4
jmp avx512_ptestm_instruction
avx512_ptestmq_instruction:
or [rex_prefix],8
mov ch,8
jmp avx512_ptestm_instruction
avx512_ptestmw_instruction:
or [rex_prefix],8
avx512_ptestmb_instruction:
xor ch,ch
avx512_ptestm_instruction:
mov ah,66h
avx512_ptest_instruction:
xor cl,cl
mov [opcode_prefix],ah
mov [supplemental_code],al
mov al,38h
or [vex_required],8
jmp avx_cmp_common
mask_shift_instruction_q:
or [rex_prefix],8
mask_shift_instruction_d:
or [operand_flags],2
or [immediate_size],1
mov [opcode_prefix],66h
mov [supplemental_code],al
mov al,3Ah
jmp mask_instruction
mask_instruction_single_source_b:
mov [opcode_prefix],66h
jmp mask_instruction_single_source_w
mask_instruction_single_source_d:
mov [opcode_prefix],66h
mask_instruction_single_source_q:
or [rex_prefix],8
mask_instruction_single_source_w:
or [operand_flags],2
jmp mask_instruction
mask_instruction_b:
mov [opcode_prefix],66h
jmp mask_instruction_w
mask_instruction_d:
mov [opcode_prefix],66h
mask_instruction_q:
or [rex_prefix],8
mask_instruction_w:
mov [operand_size],32
mask_instruction:
or [vex_required],1
mov [base_code],0Fh
mov [extended_code],al
call take_mask_register
mov [postbyte_register],al
test [operand_flags],2
jnz mask_instruction_nds_ok
lods byte [esi]
cmp al,','
jne invalid_operand
call take_mask_register
mov [vex_register],al
mask_instruction_nds_ok:
lods byte [esi]
cmp al,','
jne invalid_operand
call take_mask_register
mov bl,al
cmp [immediate_size],0
jne mmx_nomem_imm8
jmp nomem_instruction_ready
take_mask_register:
lods byte [esi]
cmp al,14h
jne invalid_operand
lods byte [esi]
convert_mask_register:
mov ah,al
shr ah,4
cmp ah,5
jne invalid_operand
and al,1111b
ret
kmov_instruction:
mov [mmx_size],al
or [vex_required],1
mov [base_code],0Fh
mov [extended_code],90h
lods byte [esi]
cmp al,14h
je kmov_maskreg
cmp al,10h
je kmov_reg
call get_size_operator
inc [extended_code]
cmp al,'['
jne invalid_argument
call get_address
lods byte [esi]
cmp al,','
jne invalid_operand
call take_mask_register
mov [postbyte_register],al
kmov_with_mem:
mov ah,[mmx_size]
mov al,[operand_size]
or al,al
jz kmov_mem_size_ok
cmp al,ah
jne invalid_operand_size
kmov_mem_size_ok:
call setup_kmov_prefix
jmp instruction_ready
setup_kmov_prefix:
cmp ah,4
jb kmov_w_ok
or [rex_prefix],8
kmov_w_ok:
test ah,1 or 4
jz kmov_prefix_ok
mov [opcode_prefix],66h
kmov_prefix_ok:
ret
kmov_maskreg:
lods byte [esi]
call convert_mask_register
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
cmp al,14h
je kmov_maskreg_maskreg
cmp al,10h
je kmov_maskreg_reg
call get_size_operator
cmp al,'['
jne invalid_argument
call get_address
jmp kmov_with_mem
kmov_maskreg_maskreg:
lods byte [esi]
call convert_mask_register
mov bl,al
mov ah,[mmx_size]
call setup_kmov_prefix
jmp nomem_instruction_ready
kmov_maskreg_reg:
add [extended_code],2
lods byte [esi]
call convert_register
kmov_with_reg:
mov bl,al
mov al,[mmx_size]
mov ah,4
cmp al,ah
jbe kmov_reg_size_check
mov ah,al
kmov_reg_size_check:
cmp ah,[operand_size]
jne invalid_operand_size
cmp al,8
je kmov_f2_w1
cmp al,2
ja kmov_f2
je nomem_instruction_ready
mov [opcode_prefix],66h
jmp nomem_instruction_ready
kmov_f2_w1:
or [rex_prefix],8
kmov_f2:
mov [opcode_prefix],0F2h
jmp nomem_instruction_ready
kmov_reg:
add [extended_code],3
lods byte [esi]
call convert_register
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_mask_register
jmp kmov_with_reg
avx512_pmov_m2_instruction_w1:
or [rex_prefix],8
avx512_pmov_m2_instruction:
or [vex_required],8
call setup_f3_0f_38
call take_avx_register
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_mask_register
mov bl,al
jmp nomem_instruction_ready
avx512_pmov_2m_instruction_w1:
or [rex_prefix],8
avx512_pmov_2m_instruction:
or [vex_required],8
call setup_f3_0f_38
call take_mask_register
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov bl,al
jmp nomem_instruction_ready
setup_f3_0f_38:
mov [extended_code],38h
mov [supplemental_code],al
mov [base_code],0Fh
mov [opcode_prefix],0F3h
ret
vzeroall_instruction:
mov [operand_size],32
vzeroupper_instruction:
mov [base_code],0Fh
mov [extended_code],al
and [displacement_compression],0
call store_vex_instruction_code
jmp instruction_assembled
vldmxcsr_instruction:
or [vex_required],2
jmp fxsave_instruction
avx_perm2f128_instruction:
or [vex_required],2
xor ch,ch
avx_instruction_imm8_without_128bit:
mov [immediate_size],1
mov ah,3Ah
jmp avx_instruction_without_128bit
avx512_shuf_q_instruction:
or [rex_prefix],8
or [vex_required],8
mov ch,8
jmp avx_instruction_imm8_without_128bit
avx512_shuf_d_instruction:
or [vex_required],8
mov ch,4
jmp avx_instruction_imm8_without_128bit
avx_permd_instruction:
mov ah,38h
mov ch,4
avx_instruction_without_128bit:
xor cl,cl
call setup_avx_66_supplemental
call take_avx_register
cmp ah,32
jb invalid_operand_size
mov [postbyte_register],al
call take_avx512_mask
jmp avx_vex_reg
setup_avx_66_supplemental:
mov [opcode_prefix],66h
mov [broadcast_size],ch
mov [mmx_size],cl
mov [base_code],0Fh
mov [extended_code],ah
mov [supplemental_code],al
or [vex_required],1
ret
avx_permq_instruction:
or [rex_prefix],8
mov ch,8
jmp avx_permil_instruction
avx_permilpd_instruction:
or [rex_prefix],80h
mov ch,8
jmp avx_permil_instruction
avx_permilps_instruction:
mov ch,4
avx_permil_instruction:
or [operand_flags],2
xor cl,cl
mov ah,3Ah
call setup_avx_66_supplemental
call take_avx_register
cmp [supplemental_code],4
jae avx_permil_size_ok
cmp ah,32
jb invalid_operand_size
avx_permil_size_ok:
mov [postbyte_register],al
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_rm
jnc mmx_imm8
mov bl,al
cmp byte [esi],','
jne invalid_operand
mov al,[esi+1]
cmp al,11h
jne avx_permil_rm_or_imm8
mov al,[esi+3]
avx_permil_rm_or_imm8:
cmp al,'('
je mmx_nomem_imm8
mov [vex_register],bl
inc esi
mov [extended_code],38h
mov al,[supplemental_code]
cmp al,4
jb avx_permq_rm
add [supplemental_code],8
jmp avx_regs_rm
avx_permq_rm:
or [vex_required],8
shl al,5
neg al
add al,36h
mov [supplemental_code],al
jmp avx_regs_rm
vpermil_2pd_instruction:
mov [immediate_size],-2
mov byte [value],al
mov al,49h
jmp vpermil2_instruction_setup
vpermil_2ps_instruction:
mov [immediate_size],-2
mov byte [value],al
mov al,48h
jmp vpermil2_instruction_setup
vpermil2_instruction:
mov [immediate_size],-3
mov byte [value],0
vpermil2_instruction_setup:
or [vex_required],2
mov [base_code],0Fh
mov [supplemental_code],al
mov al,3Ah
xor cl,cl
jmp avx_instruction
avx_shift_q_instruction_evex:
or [vex_required],8
avx_shift_q_instruction:
or [rex_prefix],80h
mov cl,8
jmp avx_shift_instruction
avx_shift_d_instruction:
mov cl,4
jmp avx_shift_instruction
avx_shift_bw_instruction:
xor cl,cl
avx_shift_instruction:
mov [broadcast_size],cl
mov [mmx_size],0
mov [opcode_prefix],66h
mov [base_code],0Fh
mov [extended_code],al
or [vex_required],1
call take_avx_register
mov [postbyte_register],al
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
xor cl,cl
xchg cl,[operand_size]
lods byte [esi]
call get_size_operator
cmp al,'['
je avx_shift_reg_mem
mov [operand_size],cl
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_avx_register
mov [vex_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
push esi
xor cl,cl
xchg cl,[operand_size]
lods byte [esi]
call get_size_operator
cmp al,10h
je avx_shift_reg_reg_reg
pop esi
cmp al,'['
je avx_shift_reg_reg_mem
xchg cl,[operand_size]
test cl,not 1
jnz invalid_operand_size
dec esi
call convert_avx_shift_opcode
mov bl,al
jmp mmx_nomem_imm8
convert_avx_shift_opcode:
mov al,[extended_code]
mov ah,al
and ah,1111b
add ah,70h
mov [extended_code],ah
shr al,4
sub al,0Ch
shl al,1
xchg al,[postbyte_register]
xchg al,[vex_register]
ret
avx_shift_reg_reg_reg:
pop eax
lods byte [esi]
call convert_xmm_register
xchg cl,[operand_size]
mov bl,al
jmp nomem_instruction_ready
avx_shift_reg_reg_mem:
mov [mmx_size],16
push ecx
lods byte [esi]
call get_size_operator
call get_address
pop eax
xchg al,[operand_size]
test al,al
jz instruction_ready
cmp al,16
jne invalid_operand_size
jmp instruction_ready
avx_shift_reg_mem:
or [vex_required],8
call take_avx_mem
call convert_avx_shift_opcode
jmp mmx_imm8
avx_shift_dq_instruction:
mov [postbyte_register],al
mov [opcode_prefix],66h
mov [base_code],0Fh
mov [extended_code],73h
or [vex_required],1
mov [mmx_size],0
call take_avx_register
mov [vex_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,'['
je avx_shift_dq_reg_mem
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_avx_register
mov bl,al
jmp mmx_nomem_imm8
avx_shift_dq_reg_mem:
or [vex_required],8
call get_address
jmp mmx_imm8
avx512_rotate_q_instruction:
mov cl,8
or [rex_prefix],cl
jmp avx512_rotate_instruction
avx512_rotate_d_instruction:
mov cl,4
avx512_rotate_instruction:
mov [broadcast_size],cl
mov [postbyte_register],al
mov [opcode_prefix],66h
mov [base_code],0Fh
mov [extended_code],72h
or [vex_required],8
mov [mmx_size],0
mov [immediate_size],1
call take_avx_register
mov [vex_register],al
call take_avx512_mask
jmp avx_vex_reg_ok
avx_pmovsxbq_instruction:
mov cl,2
jmp avx_pmovsx_instruction
avx_pmovsxbd_instruction:
mov cl,4
jmp avx_pmovsx_instruction
avx_pmovsxbw_instruction:
mov cl,8
avx_pmovsx_instruction:
mov [mmx_size],cl
or [vex_required],1
call setup_66_0f_38
call take_avx_register
mov [postbyte_register],al
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
xor al,al
xchg al,[operand_size]
bsf ecx,eax
sub cl,4
shl [mmx_size],cl
push eax
lods byte [esi]
call get_size_operator
cmp al,10h
je avx_pmovsx_reg_reg
cmp al,'['
jne invalid_operand
call get_address
pop eax
xchg al,[operand_size]
or al,al
jz instruction_ready
cmp al,[mmx_size]
jne invalid_operand_size
jmp instruction_ready
avx_pmovsx_reg_reg:
lods byte [esi]
call convert_avx_register
mov bl,al
cmp ah,[mmx_size]
je avx_pmovsx_xmmreg_reg_size_ok
jb invalid_operand_size
cmp ah,16
jne invalid_operand_size
avx_pmovsx_xmmreg_reg_size_ok:
pop eax
mov [operand_size],al
jmp nomem_instruction_ready
avx512_pmovqb_instruction:
mov cl,2
jmp avx512_pmov_instruction
avx512_pmovdb_instruction:
mov cl,4
jmp avx512_pmov_instruction
avx512_pmovwb_instruction:
mov cl,8
avx512_pmov_instruction:
mov [mmx_size],cl
or [vex_required],8
mov [extended_code],38h
mov [supplemental_code],al
mov [base_code],0Fh
mov [opcode_prefix],0F3h
lods byte [esi]
call get_size_operator
cmp al,10h
je avx512_pmov_reg
cmp al,'['
jne invalid_operand
call get_address
or [operand_flags],20h
call avx512_pmov_common
or al,al
jz instruction_ready
cmp al,[mmx_size]
jne invalid_operand_size
jmp instruction_ready
avx512_pmov_common:
call take_avx512_mask
xor al,al
xchg al,[operand_size]
push eax
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [postbyte_register],al
mov al,ah
mov ah,cl
bsf ecx,eax
sub cl,4
shl [mmx_size],cl
mov cl,ah
pop eax
ret
avx512_pmov_reg:
lods byte [esi]
call convert_avx_register
mov bl,al
call avx512_pmov_common
cmp al,[mmx_size]
je nomem_instruction_ready
jb invalid_operand_size
cmp al,16
jne invalid_operand_size
jmp nomem_instruction_ready
avx_broadcast_128_instruction_noevex:
or [vex_required],2
mov cl,10h
jmp avx_broadcast_instruction
avx512_broadcast_32x2_instruction:
mov cl,08h
jmp avx_broadcast_instruction_evex
avx512_broadcast_32x4_instruction:
mov cl,10h
jmp avx_broadcast_instruction_evex
avx512_broadcast_32x8_instruction:
mov cl,20h
jmp avx_broadcast_instruction_evex
avx512_broadcast_64x2_instruction:
mov cl,10h
jmp avx_broadcast_instruction_w1_evex
avx512_broadcast_64x4_instruction:
mov cl,20h
avx_broadcast_instruction_w1_evex:
or [rex_prefix],8
avx_broadcast_instruction_evex:
or [vex_required],8
jmp avx_broadcast_instruction
avx_broadcastss_instruction:
mov cl,4
jmp avx_broadcast_instruction
avx_broadcastsd_instruction:
or [rex_prefix],80h
mov cl,8
jmp avx_broadcast_instruction
avx_pbroadcastb_instruction:
mov cl,1
jmp avx_broadcast_pi_instruction
avx_pbroadcastw_instruction:
mov cl,2
jmp avx_broadcast_pi_instruction
avx_pbroadcastd_instruction:
mov cl,4
jmp avx_broadcast_pi_instruction
avx_pbroadcastq_instruction:
mov cl,8
or [rex_prefix],80h
avx_broadcast_pi_instruction:
or [operand_flags],40h
avx_broadcast_instruction:
mov [opcode_prefix],66h
mov [supplemental_code],al
mov al,38h
mov [mmx_size],cl
mov [base_code],0Fh
mov [extended_code],al
or [vex_required],1
call take_avx_register
cmp ah,[mmx_size]
je invalid_operand_size
test [operand_flags],40h
jnz avx_broadcast_destination_size_ok
cmp [mmx_size],4
je avx_broadcast_destination_size_ok
cmp [supplemental_code],59h
je avx_broadcast_destination_size_ok
cmp ah,16
je invalid_operand_size
avx_broadcast_destination_size_ok:
xor ah,ah
xchg ah,[operand_size]
push eax
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
je avx_broadcast_reg_reg
cmp al,'['
jne invalid_operand
call get_address
pop eax
xchg ah,[operand_size]
mov [postbyte_register],al
mov al,[broadcast_size]
mov al,[mmx_size]
cmp al,ah
je instruction_ready
or al,al
jz instruction_ready
or ah,ah
jz instruction_ready
jmp invalid_operand_size
avx_broadcast_reg_reg:
lods byte [esi]
test [operand_flags],40h
jz avx_broadcast_reg_avx_reg
cmp al,60h
jb avx_broadcast_reg_general_reg
cmp al,80h
jb avx_broadcast_reg_avx_reg
cmp al,0C0h
jb avx_broadcast_reg_general_reg
avx_broadcast_reg_avx_reg:
call convert_avx_register
mov bl,al
mov al,[mmx_size]
or al,al
jz avx_broadcast_reg_avx_reg_size_ok
cmp ah,16
jne invalid_operand_size
cmp al,ah
jae invalid_operand
avx_broadcast_reg_avx_reg_size_ok:
pop eax
xchg ah,[operand_size]
mov [postbyte_register],al
test [vex_required],2
jnz invalid_operand
jmp nomem_instruction_ready
avx_broadcast_reg_general_reg:
call convert_register
mov bl,al
mov al,[mmx_size]
or al,al
jz avx_broadcast_reg_general_reg_size_ok
cmp al,ah
jne invalid_operand_size
avx_broadcast_reg_general_reg_size_ok:
cmp al,4
jb avx_broadcast_reg_general_reg_ready
cmp al,8
mov al,3
jne avx_broadcast_reg_general_reg_ready
or [rex_prefix],8
avx_broadcast_reg_general_reg_ready:
add al,7Ah-1
mov [supplemental_code],al
or [vex_required],8
pop eax
xchg ah,[operand_size]
mov [postbyte_register],al
jmp nomem_instruction_ready
avx512_extract_64x4_instruction:
or [rex_prefix],8
avx512_extract_32x8_instruction:
or [vex_required],8
mov cl,32
jmp avx_extractf_instruction
avx512_extract_64x2_instruction:
or [rex_prefix],8
avx512_extract_32x4_instruction:
or [vex_required],8
mov cl,16
jmp avx_extractf_instruction
avx_extractf128_instruction:
or [vex_required],2
mov cl,16
avx_extractf_instruction:
mov [mmx_size],cl
call setup_66_0f_3a
lods byte [esi]
call get_size_operator
cmp al,10h
je avx_extractf_reg
cmp al,'['
jne invalid_operand
call get_address
xor al,al
xchg al,[operand_size]
or al,al
jz avx_extractf_mem_size_ok
cmp al,[mmx_size]
jne invalid_operand_size
avx_extractf_mem_size_ok:
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
cmp ah,[mmx_size]
jbe invalid_operand_size
mov [postbyte_register],al
jmp mmx_imm8
avx_extractf_reg:
lods byte [esi]
call convert_avx_register
cmp ah,[mmx_size]
jne invalid_operand_size
push eax
call take_avx512_mask
mov [operand_size],0
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
cmp ah,[mmx_size]
jbe invalid_operand_size
mov [postbyte_register],al
pop ebx
jmp mmx_nomem_imm8
avx512_insert_64x4_instruction:
or [rex_prefix],8
avx512_insert_32x8_instruction:
or [vex_required],8
mov cl,32
jmp avx_insertf_instruction
avx512_insert_64x2_instruction:
or [rex_prefix],8
avx512_insert_32x4_instruction:
or [vex_required],8
mov cl,16
jmp avx_insertf_instruction
avx_insertf128_instruction:
or [vex_required],2
mov cl,16
avx_insertf_instruction:
mov [mmx_size],cl
mov [broadcast_size],0
call setup_66_0f_3a
call take_avx_register
cmp ah,[mmx_size]
jbe invalid_operand
mov [postbyte_register],al
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [vex_register],al
mov al,[mmx_size]
xchg al,[operand_size]
push eax
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
je avx_insertf_reg_reg_reg
cmp al,'['
jne invalid_operand
call get_address
pop eax
mov [operand_size],al
jmp mmx_imm8
avx_insertf_reg_reg_reg:
lods byte [esi]
call convert_avx_register
mov bl,al
pop eax
mov [operand_size],al
jmp mmx_nomem_imm8
avx_extract_b_instruction:
mov cl,1
jmp avx_extract_instruction
avx_extract_w_instruction:
mov cl,2
jmp avx_extract_instruction
avx_extract_q_instruction:
or [rex_prefix],8
mov cl,8
jmp avx_extract_instruction
avx_extract_d_instruction:
mov cl,4
avx_extract_instruction:
mov [mmx_size],cl
call setup_66_0f_3a
or [vex_required],1
lods byte [esi]
call get_size_operator
cmp al,10h
je avx_extractps_reg
cmp al,'['
jne invalid_operand
call get_address
mov al,[mmx_size]
not al
and [operand_size],al
jnz invalid_operand_size
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_avx_register
cmp ah,16
jne invalid_operand_size
mov [postbyte_register],al
jmp mmx_imm8
avx_extractps_reg:
lods byte [esi]
call convert_register
mov bl,al
mov al,[mmx_size]
cmp ah,al
jb invalid_operand_size
cmp ah,4
je avx_extractps_reg_size_ok
cmp ah,8
jne invalid_operand_size
cmp [code_type],64
jne invalid_operand
cmp al,4
jae avx_extractps_reg_size_ok
or [rex_prefix],8
avx_extractps_reg_size_ok:
mov [operand_size],0
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_avx_register
cmp ah,16
jne invalid_operand_size
mov [postbyte_register],al
cmp [supplemental_code],15h
jne mmx_nomem_imm8
mov [extended_code],0C5h
xchg bl,[postbyte_register]
jmp mmx_nomem_imm8
avx_insertps_instruction:
mov [immediate_size],1
or [operand_flags],10h
mov [opcode_prefix],66h
mov [supplemental_code],al
mov al,3Ah
mov cl,4
jmp avx_instruction
avx_pinsrb_instruction:
mov cl,1
jmp avx_pinsr_instruction_3a
avx_pinsrw_instruction:
mov cl,2
jmp avx_pinsr_instruction
avx_pinsrd_instruction:
mov cl,4
jmp avx_pinsr_instruction_3a
avx_pinsrq_instruction:
mov cl,8
or [rex_prefix],8
avx_pinsr_instruction_3a:
mov [supplemental_code],al
mov al,3Ah
avx_pinsr_instruction:
mov [opcode_prefix],66h
mov [base_code],0Fh
mov [extended_code],al
mov [mmx_size],cl
or [vex_required],1
call take_avx_register
cmp ah,16
jne invalid_operand_size
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [vex_register],al
jmp pinsr_xmmreg
avx_cvtudq2pd_instruction:
or [vex_required],8
avx_cvtdq2pd_instruction:
mov [opcode_prefix],0F3h
mov cl,4
jmp avx_cvt_d_instruction
avx_cvtps2qq_instruction:
or [operand_flags],8
avx_cvttps2qq_instruction:
or [operand_flags],4
or [vex_required],8
mov [opcode_prefix],66h
mov cl,4
jmp avx_cvt_d_instruction
avx_cvtps2pd_instruction:
or [operand_flags],4
mov cl,4
avx_cvt_d_instruction:
mov [base_code],0Fh
mov [extended_code],al
or [vex_required],1
mov [broadcast_size],cl
call take_avx_register
mov [postbyte_register],al
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
xor ecx,ecx
xchg cl,[operand_size]
mov al,cl
shr al,1
mov [mmx_size],al
lods byte [esi]
call get_size_operator
cmp al,'['
je avx_cvt_d_reg_mem
cmp al,10h
jne invalid_operand
mov [operand_size],0
lods byte [esi]
call convert_avx_register
cmp ah,[mmx_size]
je avx_cvt_d_reg_reg_size_ok
jb invalid_operand_size
cmp ah,16
jne invalid_operand_size
avx_cvt_d_reg_reg_size_ok:
mov bl,al
mov [operand_size],cl
call take_avx512_rounding
jmp nomem_instruction_ready
avx_cvt_d_reg_mem:
call take_avx_mem
jmp instruction_ready
avx_cvtpd2dq_instruction:
or [operand_flags],4+8
mov [opcode_prefix],0F2h
jmp avx_cvt_q_instruction
avx_cvtuqq2ps_instruction:
mov [opcode_prefix],0F2h
avx_cvtpd2udq_instruction:
or [operand_flags],8
avx_cvttpd2udq_instruction:
or [operand_flags],4
or [vex_required],8
jmp avx_cvt_q_instruction
avx_cvtpd2ps_instruction:
or [operand_flags],8
avx_cvttpd2dq_instruction:
or [operand_flags],4
mov [opcode_prefix],66h
avx_cvt_q_instruction:
mov [broadcast_size],8
mov [base_code],0Fh
mov [extended_code],al
or [vex_required],1
or [rex_prefix],80h
call take_avx_register
mov [postbyte_register],al
push eax
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
xor al,al
mov [operand_size],al
mov [mmx_size],al
call take_avx_rm
jnc avx_cvt_q_reg_mem
mov bl,al
pop eax
call avx_cvt_q_check_size
call take_avx512_rounding
jmp nomem_instruction_ready
avx_cvt_q_reg_mem:
pop eax
call avx_cvt_q_check_size
jmp instruction_ready
avx_cvt_q_check_size:
mov al,[operand_size]
or al,al
jz avx_cvt_q_size_not_specified
shr al,1
cmp al,ah
je avx_cvt_q_size_ok
ja invalid_operand_size
cmp ah,16
jne invalid_operand_size
avx_cvt_q_size_ok:
ret
avx_cvt_q_size_not_specified:
cmp ah,64 shr 1
jne recoverable_unknown_size
mov [operand_size],64
ret
avx_cvttps2udq_instruction:
or [vex_required],8
or [operand_flags],2+4
mov cx,0400h
jmp avx_instruction_with_broadcast
avx_cvttps2dq_instruction:
mov [opcode_prefix],0F3h
or [operand_flags],2+4
mov cx,0400h
jmp avx_instruction_with_broadcast
avx_cvtph2ps_instruction:
mov [opcode_prefix],66h
mov [supplemental_code],al
or [operand_flags],4
mov al,38h
xor cl,cl
jmp avx_cvt_d_instruction
avx_cvtps2ph_instruction:
call setup_66_0f_3a
or [vex_required],1
or [operand_flags],4
lods byte [esi]
call get_size_operator
cmp al,10h
je vcvtps2ph_reg
cmp al,'['
jne invalid_operand
call get_address
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
shl [operand_size],1
call take_avx_register
mov [postbyte_register],al
shr ah,1
mov [mmx_size],ah
jmp mmx_imm8
vcvtps2ph_reg:
lods byte [esi]
call convert_avx_register
mov bl,al
call take_avx512_mask
xor cl,cl
xchg cl,[operand_size]
shl cl,1
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [postbyte_register],al
or cl,cl
jz vcvtps2ph_reg_size_ok
cmp cl,ah
je vcvtps2ph_reg_size_ok
jb invalid_operand_size
cmp ah,16
jne invalid_operand_size
vcvtps2ph_reg_size_ok:
call take_avx512_rounding
jmp mmx_nomem_imm8
avx_cvtsd2usi_instruction:
or [operand_flags],8
avx_cvttsd2usi_instruction:
or [vex_required],8
jmp avx_cvttsd2si_instruction
avx_cvtsd2si_instruction:
or [operand_flags],8
avx_cvttsd2si_instruction:
mov ah,0F2h
mov cl,8
jmp avx_cvt_2si_instruction
avx_cvtss2usi_instruction:
or [operand_flags],8
avx_cvttss2usi_instruction:
or [vex_required],8
jmp avx_cvttss2si_instruction
avx_cvtss2si_instruction:
or [operand_flags],8
avx_cvttss2si_instruction:
mov ah,0F3h
mov cl,4
avx_cvt_2si_instruction:
or [operand_flags],2+4
mov [mmx_size],cl
mov [broadcast_size],0
mov [opcode_prefix],ah
mov [base_code],0Fh
mov [extended_code],al
or [vex_required],1
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_register
mov [postbyte_register],al
mov [operand_size],0
cmp ah,4
je avx_cvt_2si_reg
cmp ah,8
jne invalid_operand_size
call operand_64bit
avx_cvt_2si_reg:
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_rm
jnc instruction_ready
mov bl,al
call take_avx512_rounding
jmp nomem_instruction_ready
avx_cvtusi2sd_instruction:
or [vex_required],8
avx_cvtsi2sd_instruction:
mov ah,0F2h
mov cl,8
jmp avx_cvtsi_instruction
avx_cvtusi2ss_instruction:
or [vex_required],8
avx_cvtsi2ss_instruction:
mov ah,0F3h
mov cl,4
avx_cvtsi_instruction:
or [operand_flags],2+4+8
mov [mmx_size],cl
mov [opcode_prefix],ah
mov [base_code],0Fh
mov [extended_code],al
or [vex_required],1
call take_avx_register
cmp ah,16
jne invalid_operand_size
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [vex_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
mov [operand_size],0
lods byte [esi]
call get_size_operator
cmp al,'['
je avx_cvtsi_reg_reg_mem
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_register
mov bl,al
cmp ah,4
je avx_cvtsi_reg_reg_reg32
cmp ah,8
jne invalid_operand_size
call operand_64bit
avx_cvtsi_rounding:
call take_avx512_rounding
jmp nomem_instruction_ready
avx_cvtsi_reg_reg_reg32:
cmp [mmx_size],8
jne avx_cvtsi_rounding
jmp nomem_instruction_ready
avx_cvtsi_reg_reg_mem:
call get_address
mov al,[operand_size]
mov [mmx_size],al
or al,al
jz single_mem_nosize
cmp al,4
je instruction_ready
cmp al,8
jne invalid_operand_size
call operand_64bit
jmp instruction_ready
avx_maskmov_w1_instruction:
or [rex_prefix],8
avx_maskmov_instruction:
call setup_66_0f_38
mov [mmx_size],0
or [vex_required],2
lods byte [esi]
call get_size_operator
cmp al,10h
jne avx_maskmov_mem
lods byte [esi]
call convert_avx_register
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [vex_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
cmp al,'['
jne invalid_operand
call get_address
jmp instruction_ready
avx_maskmov_mem:
cmp al,'['
jne invalid_operand
call get_address
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [vex_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov [postbyte_register],al
add [supplemental_code],2
jmp instruction_ready
avx_movmskpd_instruction:
mov [opcode_prefix],66h
avx_movmskps_instruction:
mov [base_code],0Fh
mov [extended_code],50h
or [vex_required],2
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_register
mov [postbyte_register],al
cmp ah,4
je avx_movmskps_reg_ok
cmp ah,8
jne invalid_operand_size
cmp [code_type],64
jne invalid_operand
avx_movmskps_reg_ok:
mov [operand_size],0
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov bl,al
jmp nomem_instruction_ready
avx_maskmovdqu_instruction:
or [vex_required],2
jmp maskmovdqu_instruction
avx_pmovmskb_instruction:
or [vex_required],2
mov [opcode_prefix],66h
mov [base_code],0Fh
mov [extended_code],al
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_register
cmp ah,4
je avx_pmovmskb_reg_size_ok
cmp [code_type],64
jne invalid_operand_size
cmp ah,8
jnz invalid_operand_size
avx_pmovmskb_reg_size_ok:
mov [postbyte_register],al
mov [operand_size],0
lods byte [esi]
cmp al,','
jne invalid_operand
call take_avx_register
mov bl,al
jmp nomem_instruction_ready
gather_pd_instruction:
or [rex_prefix],8
gather_ps_instruction:
call setup_66_0f_38
or [vex_required],4
or [operand_flags],20h
call take_avx_register
mov [postbyte_register],al
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
xor cl,cl
xchg cl,[operand_size]
push ecx
lods byte [esi]
call get_size_operator
cmp al,'['
jne invalid_argument
call get_address
pop eax
xchg al,[operand_size]
gather_mem_size_check:
mov ah,4
test [rex_prefix],8
jz gather_elements_size_ok
add ah,ah
gather_elements_size_ok:
mov [mmx_size],ah
test al,al
jz gather_mem_size_ok
cmp al,ah
jne invalid_operand_size
gather_mem_size_ok:
cmp byte [esi],','
je gather_reg_mem_reg
test [vex_required],20h
jz invalid_operand
mov ah,[operand_size]
mov al,80h
jmp gather_arguments_ok
gather_reg_mem_reg:
or [vex_required],2
inc esi
call take_avx_register
gather_arguments_ok:
mov [vex_register],al
cmp al,[postbyte_register]
je disallowed_combination_of_registers
mov al,bl
and al,11111b
cmp al,[postbyte_register]
je disallowed_combination_of_registers
cmp al,[vex_register]
je disallowed_combination_of_registers
mov al,bl
shr al,5
cmp al,0Ch shr 1
je gather_vr128
mov ah,32
cmp al,6 shr 1
jne gather_regular
add ah,ah
gather_regular:
mov al,[rex_prefix]
shr al,3
xor al,[supplemental_code]
test al,1
jz gather_uniform
test [supplemental_code],1
jz gather_double
mov al,ah
xchg al,[operand_size]
add al,al
cmp al,ah
jne invalid_operand_size
jmp instruction_ready
gather_double:
add ah,ah
gather_uniform:
cmp ah,[operand_size]
jne invalid_operand_size
jmp instruction_ready
gather_vr128:
cmp ah,16
je instruction_ready
cmp ah,32
jne invalid_operand_size
test [supplemental_code],1
jnz invalid_operand_size
test [rex_prefix],8
jz invalid_operand_size
jmp instruction_ready
scatter_pd_instruction:
or [rex_prefix],8
scatter_ps_instruction:
call setup_66_0f_38
or [vex_required],4+8
or [operand_flags],20h
lods byte [esi]
call get_size_operator
cmp al,'['
jne invalid_argument
call get_address
call take_avx512_mask
lods byte [esi]
cmp al,','
jne invalid_operand
xor al,al
xchg al,[operand_size]
push eax
call take_avx_register
mov [postbyte_register],al
pop eax
jmp gather_mem_size_check
gatherpf_qpd_instruction:
mov ah,0C7h
jmp gatherpf_pd_instruction
gatherpf_dpd_instruction:
mov ah,0C6h
gatherpf_pd_instruction:
or [rex_prefix],8
mov cl,8
jmp gatherpf_instruction
gatherpf_qps_instruction:
mov ah,0C7h
jmp gatherpf_ps_instruction
gatherpf_dps_instruction:
mov ah,0C6h
gatherpf_ps_instruction:
mov cl,4
gatherpf_instruction:
mov [mmx_size],cl
mov [postbyte_register],al
mov al,ah
call setup_66_0f_38
or [vex_required],4+8
or [operand_flags],20h
lods byte [esi]
call get_size_operator
cmp al,'['
jne invalid_argument
call get_address
call take_avx512_mask
mov ah,[mmx_size]
mov al,[operand_size]
or al,al
jz gatherpf_mem_size_ok
cmp al,ah
jne invalid_operand_size
gatherpf_mem_size_ok:
mov [operand_size],64
mov al,6 shr 1
cmp ah,4
je gatherpf_check_vsib
cmp [supplemental_code],0C6h
jne gatherpf_check_vsib
mov al,0Eh shr 1
gatherpf_check_vsib:
mov ah,bl
shr ah,5
cmp al,ah
jne invalid_operand
jmp instruction_ready
bmi_instruction:
mov [base_code],0Fh
mov [extended_code],38h
mov [supplemental_code],0F3h
mov [postbyte_register],al
bmi_reg:
or [vex_required],2
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_register
mov [vex_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
je bmi_reg_reg
cmp al,'['
jne invalid_argument
call get_address
call operand_32or64
jmp instruction_ready
bmi_reg_reg:
lods byte [esi]
call convert_register
mov bl,al
call operand_32or64
jmp nomem_instruction_ready
operand_32or64:
mov al,[operand_size]
cmp al,4
je operand_32or64_ok
cmp al,8
jne invalid_operand_size
cmp [code_type],64
jne invalid_operand
or [rex_prefix],8
operand_32or64_ok:
ret
pdep_instruction:
mov [opcode_prefix],0F2h
jmp andn_instruction
pext_instruction:
mov [opcode_prefix],0F3h
andn_instruction:
mov [base_code],0Fh
mov [extended_code],38h
mov [supplemental_code],al
or [vex_required],2
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_register
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
jmp bmi_reg
sarx_instruction:
mov [opcode_prefix],0F3h
jmp bzhi_instruction
shrx_instruction:
mov [opcode_prefix],0F2h
jmp bzhi_instruction
shlx_instruction:
mov [opcode_prefix],66h
bzhi_instruction:
mov [base_code],0Fh
mov [extended_code],38h
mov [supplemental_code],al
or [vex_required],2
call get_reg_mem
jc bzhi_reg_reg
call get_vex_source_register
jc invalid_operand
call operand_32or64
jmp instruction_ready
bzhi_reg_reg:
call get_vex_source_register
jc invalid_operand
call operand_32or64
jmp nomem_instruction_ready
get_vex_source_register:
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,10h
jne no_vex_source_register
lods byte [esi]
call convert_register
mov [vex_register],al
clc
ret
no_vex_source_register:
stc
ret
bextr_instruction:
mov [base_code],0Fh
mov [extended_code],38h
mov [supplemental_code],al
or [vex_required],2
call get_reg_mem
jc bextr_reg_reg
call get_vex_source_register
jc bextr_reg_mem_imm32
call operand_32or64
jmp instruction_ready
bextr_reg_reg:
call get_vex_source_register
jc bextr_reg_reg_imm32
call operand_32or64
jmp nomem_instruction_ready
setup_bextr_imm_opcode:
mov [xop_opcode_map],0Ah
mov [base_code],10h
call operand_32or64
ret
bextr_reg_mem_imm32:
call get_imm32
call setup_bextr_imm_opcode
jmp store_instruction_with_imm32
bextr_reg_reg_imm32:
call get_imm32
call setup_bextr_imm_opcode
store_nomem_instruction_with_imm32:
call store_nomem_instruction
mov eax,dword [value]
call mark_relocation
stos dword [edi]
jmp instruction_assembled
get_imm32:
cmp al,'('
jne invalid_operand
push edx ebx ecx
call get_dword_value
mov dword [value],eax
pop ecx ebx edx
ret
rorx_instruction:
mov [opcode_prefix],0F2h
mov [base_code],0Fh
mov [extended_code],3Ah
mov [supplemental_code],al
or [vex_required],2
call get_reg_mem
jc rorx_reg_reg
call operand_32or64
jmp mmx_imm8
rorx_reg_reg:
call operand_32or64
jmp mmx_nomem_imm8
tbm_instruction:
mov [xop_opcode_map],9
mov ah,al
shr ah,4
and al,111b
mov [base_code],ah
mov [postbyte_register],al
jmp bmi_reg
llwpcb_instruction:
or [vex_required],2
mov [xop_opcode_map],9
mov [base_code],12h
mov [postbyte_register],al
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_register
mov bl,al
call operand_32or64
jmp nomem_instruction_ready
lwpins_instruction:
or [vex_required],2
mov [xop_opcode_map],0Ah
mov [base_code],12h
mov [vex_register],al
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_register
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
xor cl,cl
xchg cl,[operand_size]
lods byte [esi]
call get_size_operator
cmp al,10h
je lwpins_reg_reg
cmp al,'['
jne invalid_argument
push ecx
call get_address
pop eax
xchg al,[operand_size]
test al,al
jz lwpins_reg_mem_size_ok
cmp al,4
jne invalid_operand_size
lwpins_reg_mem_size_ok:
call prepare_lwpins
jmp store_instruction_with_imm32
lwpins_reg_reg:
lods byte [esi]
call convert_register
cmp ah,4
jne invalid_operand_size
mov [operand_size],cl
mov bl,al
call prepare_lwpins
jmp store_nomem_instruction_with_imm32
prepare_lwpins:
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_imm32
call operand_32or64
mov al,[vex_register]
xchg al,[postbyte_register]
mov [vex_register],al
ret
xop_single_source_sd_instruction:
or [operand_flags],2
mov [mmx_size],8
jmp xop_instruction_9
xop_single_source_ss_instruction:
or [operand_flags],2
mov [mmx_size],4
jmp xop_instruction_9
xop_single_source_instruction:
or [operand_flags],2
mov [mmx_size],0
xop_instruction_9:
mov [base_code],al
mov [xop_opcode_map],9
jmp avx_xop_common
xop_single_source_128bit_instruction:
or [operand_flags],2
mov [mmx_size],16
jmp xop_instruction_9
xop_triple_source_128bit_instruction:
mov [immediate_size],-1
mov byte [value],0
mov [mmx_size],16
jmp xop_instruction_8
xop_128bit_instruction:
mov [immediate_size],-2
mov byte [value],0
mov [mmx_size],16
xop_instruction_8:
mov [base_code],al
mov [xop_opcode_map],8
jmp avx_xop_common
xop_pcom_b_instruction:
mov ah,0CCh
jmp xop_pcom_instruction
xop_pcom_d_instruction:
mov ah,0CEh
jmp xop_pcom_instruction
xop_pcom_q_instruction:
mov ah,0CFh
jmp xop_pcom_instruction
xop_pcom_w_instruction:
mov ah,0CDh
jmp xop_pcom_instruction
xop_pcom_ub_instruction:
mov ah,0ECh
jmp xop_pcom_instruction
xop_pcom_ud_instruction:
mov ah,0EEh
jmp xop_pcom_instruction
xop_pcom_uq_instruction:
mov ah,0EFh
jmp xop_pcom_instruction
xop_pcom_uw_instruction:
mov ah,0EDh
xop_pcom_instruction:
mov byte [value],al
mov [immediate_size],-4
mov [mmx_size],16
mov [base_code],ah
mov [xop_opcode_map],8
jmp avx_xop_common
vpcmov_instruction:
or [vex_required],2
mov [immediate_size],-2
mov byte [value],0
mov [mmx_size],0
mov [base_code],al
mov [xop_opcode_map],8
jmp avx_xop_common
xop_shift_instruction:
mov [base_code],al
or [vex_required],2
mov [xop_opcode_map],9
call take_avx_register
cmp ah,16
jne invalid_operand
mov [postbyte_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
lods byte [esi]
call get_size_operator
cmp al,'['
je xop_shift_reg_mem
cmp al,10h
jne invalid_operand
lods byte [esi]
call convert_xmm_register
mov [vex_register],al
lods byte [esi]
cmp al,','
jne invalid_operand
push esi
xor cl,cl
xchg cl,[operand_size]
lods byte [esi]
call get_size_operator
pop esi
xchg cl,[operand_size]
cmp al,'['
je xop_shift_reg_reg_mem
cmp al,10h
jne xop_shift_reg_reg_imm
call take_avx_register
mov bl,al
xchg bl,[vex_register]
jmp nomem_instruction_ready
xop_shift_reg_reg_mem:
or [rex_prefix],8
lods byte [esi]
call get_size_operator
call get_address
jmp instruction_ready
xop_shift_reg_reg_imm:
xor bl,bl
xchg bl,[vex_register]
cmp [base_code],94h
jae invalid_operand
add [base_code],30h
mov [xop_opcode_map],8
dec esi
jmp mmx_nomem_imm8
xop_shift_reg_mem:
call get_address
lods byte [esi]
cmp al,','
jne invalid_operand
push esi
xor cl,cl
xchg cl,[operand_size]
lods byte [esi]
call get_size_operator
pop esi
xchg cl,[operand_size]
cmp al,10h
jne xop_shift_reg_mem_imm
call take_avx_register
mov [vex_register],al
jmp instruction_ready
xop_shift_reg_mem_imm:
cmp [base_code],94h
jae invalid_operand
add [base_code],30h
mov [xop_opcode_map],8
dec esi
jmp mmx_imm8
set_evex_mode:
mov [evex_mode],al
jmp instruction_assembled
take_avx_register:
lods byte [esi]
call get_size_operator
cmp al,10h
jne invalid_operand
lods byte [esi]
convert_avx_register:
mov ah,al
and al,1Fh
and ah,0E0h
sub ah,60h
jb invalid_operand
jz avx512_register_size
sub ah,60h
jb invalid_operand
jnz avx_register_size_ok
mov ah,16
jmp avx_register_size_ok
avx512_register_size:
mov ah,64
avx_register_size_ok:
cmp al,8
jb match_register_size
cmp [code_type],64
jne invalid_operand
jmp match_register_size
store_vex_instruction_code:
test [rex_prefix],10h
jnz invalid_operand
test [vex_required],0F8h
jnz store_evex_instruction_code
test [vex_register],10000b
jnz store_evex_instruction_code
cmp [operand_size],64
je store_evex_instruction_code
mov al,[base_code]
cmp al,0Fh
jne store_xop_instruction_code
test [vex_required],2
jnz prepare_vex
cmp [evex_mode],0
je prepare_vex
cmp [displacement_compression],1
jne prepare_vex
cmp edx,80h
jb prepare_vex
cmp edx,-80h
jae prepare_vex
mov al,bl
or al,bh
shr al,4
cmp al,2
je prepare_vex
call compress_displacement
cmp [displacement_compression],2
ja prepare_evex
jb prepare_vex
dec [displacement_compression]
mov edx,[uncompressed_displacement]
prepare_vex:
mov ah,[extended_code]
cmp ah,38h
je store_vex_0f38_instruction_code
cmp ah,3Ah
je store_vex_0f3a_instruction_code
test [rex_prefix],1011b
jnz store_vex_0f_instruction_code
mov [edi+2],ah
mov byte [edi],0C5h
mov al,[vex_register]
not al
shl al,3
mov ah,[rex_prefix]
shl ah,5
and ah,80h
xor al,ah
call get_vex_lpp_bits
mov [edi+1],al
call check_vex
add edi,3
ret
get_vex_lpp_bits:
cmp [operand_size],32
jne get_vex_pp_bits
or al,100b
get_vex_pp_bits:
mov ah,[opcode_prefix]
cmp ah,66h
je vex_66
cmp ah,0F3h
je vex_f3
cmp ah,0F2h
je vex_f2
test ah,ah
jnz disallowed_combination_of_registers
ret
vex_f2:
or al,11b
ret
vex_f3:
or al,10b
ret
vex_66:
or al,1
ret
store_vex_0f38_instruction_code:
mov al,11100010b
mov ah,[supplemental_code]
jmp make_c4_vex
store_vex_0f3a_instruction_code:
mov al,11100011b
mov ah,[supplemental_code]
jmp make_c4_vex
store_vex_0f_instruction_code:
mov al,11100001b
make_c4_vex:
mov [edi+3],ah
mov byte [edi],0C4h
mov ah,[rex_prefix]
shl ah,5
xor al,ah
mov [edi+1],al
call check_vex
mov al,[vex_register]
xor al,1111b
shl al,3
mov ah,[rex_prefix]
shl ah,4
and ah,80h
or al,ah
call get_vex_lpp_bits
mov [edi+2],al
add edi,4
ret
check_vex:
cmp [code_type],64
je vex_ok
not al
test al,11000000b
jnz invalid_operand
test [rex_prefix],40h
jnz invalid_operand
vex_ok:
ret
store_xop_instruction_code:
mov [edi+3],al
mov byte [edi],8Fh
mov al,[xop_opcode_map]
mov ah,[rex_prefix]
test ah,40h
jz xop_ok
cmp [code_type],64
jne invalid_operand
xop_ok:
not ah
shl ah,5
xor al,ah
mov [edi+1],al
mov al,[vex_register]
xor al,1111b
shl al,3
mov ah,[rex_prefix]
shl ah,4
and ah,80h
or al,ah
call get_vex_lpp_bits
mov [edi+2],al
add edi,4
ret
store_evex_instruction_code:
test [vex_required],2
jnz invalid_operand
cmp [base_code],0Fh
jne invalid_operand
cmp [displacement_compression],1
jne prepare_evex
call compress_displacement
prepare_evex:
mov ah,[extended_code]
cmp ah,38h
je store_evex_0f38_instruction_code
cmp ah,3Ah
je store_evex_0f3a_instruction_code
mov al,11110001b
make_evex:
mov [edi+4],ah
mov byte [edi],62h
mov ah,[rex_prefix]
shl ah,5
xor al,ah
mov ah,[vex_required]
and ah,10h
xor al,ah
mov [edi+1],al
call check_vex
mov al,[vex_register]
not al
and al,1111b
shl al,3
mov ah,[rex_prefix]
shl ah,4
or ah,[rex_prefix]
and ah,80h
or al,ah
or al,100b
call get_vex_pp_bits
mov [edi+2],al
mov al,[vex_register]
not al
shr al,1
and al,1000b
test [vex_required],80h
jne evex_rounding
mov ah,[operand_size]
cmp ah,16
jbe evex_l_ok
or al,ah
jmp evex_l_ok
evex_rounding:
mov ah,[rounding_mode]
shl ah,5
or al,ah
evex_l_ok:
test [vex_required],20h
jz evex_zaaa_ok
or al,[mask_register]
evex_zaaa_ok:
test [vex_required],40h
jz evex_b_ok
or al,10h
evex_b_ok:
mov [edi+3],al
add edi,5
ret
store_evex_0f38_instruction_code:
mov al,11110010b
mov ah,[supplemental_code]
jmp make_evex
store_evex_0f3a_instruction_code:
mov al,11110011b
mov ah,[supplemental_code]
jmp make_evex
compress_displacement:
mov ebp,ecx
mov [uncompressed_displacement],edx
or edx,edx
jz displacement_compressed
xor ecx,ecx
mov cl,[mmx_size]
test cl,cl
jnz calculate_displacement_scale
mov cl,[operand_size]
calculate_displacement_scale:
bsf ecx,ecx
jz displacement_compression_ok
xor eax,eax
shrd eax,edx,cl
jnz displacement_not_compressed
sar edx,cl
cmp edx,80h
jb displacement_compressed
cmp edx,-80h
jnb displacement_compressed
shl edx,cl
displacement_not_compressed:
inc [displacement_compression]
jmp displacement_compression_ok
displacement_compressed:
add [displacement_compression],2
displacement_compression_ok:
mov ecx,ebp
ret