| 0,0 → 1,1353 |
|---|
| |
| ; flat assembler core |
| ; Copyright (c) 1999-2011, Tomasz Grysztar. |
| ; All rights reserved. |
| |
| avx_single_source_pd_instruction: |
| or [vex_required],2 |
| jmp avx_pd_instruction |
| avx_pd_instruction_imm8: |
| mov [immediate_size],1 |
| avx_pd_instruction: |
| mov [opcode_prefix],66h |
| mov [mmx_size],0 |
| jmp avx_instruction |
| avx_single_source_ps_instruction: |
| or [vex_required],2 |
| jmp avx_ps_instruction |
| avx_ps_instruction_imm8: |
| mov [immediate_size],1 |
| avx_ps_instruction: |
| mov [mmx_size],0 |
| jmp avx_instruction |
| avx_sd_instruction_imm8: |
| mov [immediate_size],1 |
| avx_sd_instruction: |
| mov [opcode_prefix],0F2h |
| mov [mmx_size],8 |
| jmp avx_instruction |
| avx_ss_instruction_imm8: |
| mov [immediate_size],1 |
| avx_ss_instruction: |
| mov [opcode_prefix],0F3h |
| mov [mmx_size],4 |
| jmp avx_instruction |
| avx_cmp_pd_instruction: |
| mov [opcode_prefix],66h |
| avx_cmp_ps_instruction: |
| mov [mmx_size],0 |
| mov byte [value],al |
| mov al,0C2h |
| jmp avx_instruction |
| avx_cmp_sd_instruction: |
| mov [opcode_prefix],0F2h |
| mov [mmx_size],8 |
| mov byte [value],al |
| mov al,0C2h |
| jmp avx_instruction |
| avx_cmp_ss_instruction: |
| mov [opcode_prefix],0F3h |
| mov [mmx_size],4 |
| mov byte [value],al |
| mov al,0C2h |
| jmp avx_instruction |
| avx_comiss_instruction: |
| or [vex_required],2 |
| mov [mmx_size],4 |
| jmp avx_instruction |
| avx_comisd_instruction: |
| or [vex_required],2 |
| mov [opcode_prefix],66h |
| mov [mmx_size],8 |
| jmp avx_instruction |
| avx_haddps_instruction: |
| mov [opcode_prefix],0F2h |
| mov [mmx_size],0 |
| jmp avx_instruction |
| avx_movshdup_instruction: |
| or [vex_required],2 |
| mov [opcode_prefix],0F3h |
| mov [mmx_size],0 |
| avx_instruction: |
| mov [base_code],0Fh |
| mov [extended_code],al |
| avx_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 |
| avx_vex_reg: |
| test [vex_required],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: |
| cmp [mmx_size],0 |
| je avx_regs_size_ok |
| cmp ah,16 |
| jne invalid_operand |
| avx_regs_size_ok: |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| call take_avx_rm |
| jc avx_regs_reg |
| mov al,[extended_code] |
| mov ah,[supplemental_code] |
| cmp al,0C2h |
| je sse_cmp_mem_ok |
| cmp ax,443Ah |
| je sse_cmp_mem_ok |
| mov al,[base_code] |
| and al,11011100b |
| cmp al,11001100b |
| je sse_cmp_mem_ok |
| cmp [immediate_size],1 |
| je mmx_imm8 |
| cmp [immediate_size],0 |
| jge instruction_ready |
| cmp byte [esi],',' |
| jne invalid_operand |
| inc esi |
| call take_avx_register |
| shl al,4 |
| 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 |
| mov al,[extended_code] |
| mov ah,[supplemental_code] |
| cmp al,0C2h |
| je sse_cmp_nomem_ok |
| cmp ax,443Ah |
| je sse_cmp_nomem_ok |
| mov al,[base_code] |
| and al,11011100b |
| cmp al,11001100b |
| je sse_cmp_nomem_ok |
| cmp [immediate_size],1 |
| je mmx_nomem_imm8 |
| cmp [immediate_size],0 |
| jge nomem_instruction_ready |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| mov al,bl |
| shl al,4 |
| 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 |
| 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 |
| mov [operand_size],cl |
| cmp al,10h |
| jne invalid_operand |
| lods byte [esi] |
| call convert_avx_register |
| cmp [mmx_size],0 |
| je avx_reg_ok |
| cmp ah,16 |
| jne invalid_operand |
| avx_reg_ok: |
| stc |
| ret |
| take_avx_mem: |
| push ecx |
| call get_address |
| pop eax |
| cmp [mmx_size],0 |
| jne avx_smem |
| xchg al,[operand_size] |
| or al,al |
| jz avx_mem_ok |
| cmp al,[operand_size] |
| jne operand_sizes_do_not_match |
| avx_mem_ok: |
| clc |
| ret |
| avx_smem: |
| xchg al,[operand_size] |
| cmp al,[mmx_size] |
| jne invalid_operand_size |
| clc |
| ret |
| 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 |
| |
| avx_128bit_instruction: |
| mov [mmx_size],16 |
| mov [opcode_prefix],66h |
| jmp avx_instruction |
| avx_single_source_128bit_instruction_38: |
| or [vex_required],2 |
| avx_128bit_instruction_38: |
| mov [mmx_size],16 |
| avx_instruction_38_setup: |
| mov [opcode_prefix],66h |
| mov [supplemental_code],al |
| mov al,38h |
| jmp avx_instruction |
| avx_single_source_instruction_38: |
| or [vex_required],2 |
| mov [mmx_size],0 |
| jmp avx_instruction_38_setup |
| avx_ss_instruction_3a_imm8: |
| mov [mmx_size],4 |
| jmp avx_instruction_3a_imm8_setup |
| avx_sd_instruction_3a_imm8: |
| mov [mmx_size],8 |
| jmp avx_instruction_3a_imm8_setup |
| avx_single_source_128bit_instruction_3a_imm8: |
| or [vex_required],2 |
| avx_128bit_instruction_3a_imm8: |
| mov [mmx_size],16 |
| jmp avx_instruction_3a_imm8_setup |
| avx_triple_source_instruction_3a: |
| mov [mmx_size],0 |
| mov [immediate_size],-1 |
| mov byte [value],0 |
| jmp avx_instruction_3a_setup |
| avx_triple_source_128bit_instruction_3a: |
| mov [mmx_size],16 |
| mov [immediate_size],-1 |
| mov byte [value],0 |
| jmp avx_instruction_3a_setup |
| avx_single_source_instruction_3a_imm8: |
| or [vex_required],2 |
| avx_instruction_3a_imm8: |
| mov [mmx_size],0 |
| avx_instruction_3a_imm8_setup: |
| mov [immediate_size],1 |
| avx_instruction_3a_setup: |
| mov [opcode_prefix],66h |
| mov [supplemental_code],al |
| mov al,3Ah |
| jmp avx_instruction |
| avx_pclmulqdq_instruction: |
| mov byte [value],al |
| mov [mmx_size],16 |
| mov al,44h |
| jmp avx_instruction_3a_setup |
| avx_perm2f128_instruction: |
| call setup_66_0f_3a |
| mov [immediate_size],1 |
| mov [mmx_size],0 |
| or [vex_required],1 |
| call take_avx_register |
| cmp ah,32 |
| jne invalid_operand_size |
| mov [postbyte_register],al |
| jmp avx_vex_reg |
| setup_66_0f_3a: |
| mov [opcode_prefix],66h |
| mov [base_code],0Fh |
| mov [extended_code],3Ah |
| mov [supplemental_code],al |
| ret |
| |
| avx_movdqu_instruction: |
| mov [opcode_prefix],0F3h |
| jmp avx_movps_instruction |
| avx_movpd_instruction: |
| mov [opcode_prefix],66h |
| avx_movps_instruction: |
| mov [mmx_size],0 |
| or [vex_required],2 |
| mov [base_code],0Fh |
| mov [extended_code],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 |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| call take_avx_register |
| mov [postbyte_register],al |
| jmp instruction_ready |
| avx_movntpd_instruction: |
| mov [opcode_prefix],66h |
| avx_movntps_instruction: |
| or [vex_required],1 |
| mov [base_code],0Fh |
| mov [extended_code],al |
| lods byte [esi] |
| call get_size_operator |
| jmp avx_mem |
| avx_lddqu_instruction: |
| mov [opcode_prefix],0F2h |
| mov [mmx_size],0 |
| xor cl,cl |
| avx_load_instruction: |
| mov [base_code],0Fh |
| mov [extended_code],al |
| or [vex_required],1 |
| call take_avx_register |
| or cl,cl |
| jz avx_load_reg_ok |
| cmp ah,cl |
| jne invalid_operand |
| avx_load_reg_ok: |
| cmp [mmx_size],0 |
| je avx_load_reg_ |
| xor ah,ah |
| avx_load_reg_: |
| xchg ah,[operand_size] |
| push eax |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| lods byte [esi] |
| call get_size_operator |
| cmp al,'[' |
| jne invalid_operand |
| call get_address |
| pop eax |
| xchg ah,[operand_size] |
| mov [postbyte_register],al |
| mov al,[mmx_size] |
| or al,al |
| jz instruction_ready |
| or ah,ah |
| jz instruction_ready |
| cmp al,ah |
| jne invalid_operand_size |
| jmp instruction_ready |
| avx_movntdqa_instruction: |
| mov [mmx_size],16 |
| mov al,2Ah |
| mov cl,16 |
| jmp avx_load_instruction_38 |
| avx_broadcastss_instruction: |
| mov [mmx_size],4 |
| mov al,18h |
| xor cl,cl |
| jmp avx_load_instruction_38 |
| avx_broadcastsd_instruction: |
| mov [mmx_size],8 |
| mov al,19h |
| mov cl,32 |
| jmp avx_load_instruction_38 |
| avx_broadcastf128_instruction: |
| mov [mmx_size],16 |
| mov al,1Ah |
| mov cl,32 |
| avx_load_instruction_38: |
| mov [opcode_prefix],66h |
| mov [supplemental_code],al |
| mov al,38h |
| jmp avx_load_instruction |
| avx_movlpd_instruction: |
| mov [opcode_prefix],66h |
| avx_movlps_instruction: |
| mov [base_code],0Fh |
| mov [extended_code],al |
| mov [mmx_size],8 |
| 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 |
| 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_maskmov_instruction: |
| mov [opcode_prefix],66h |
| mov [base_code],0Fh |
| mov [extended_code],38h |
| mov [supplemental_code],al |
| mov [mmx_size],0 |
| or [vex_required],1 |
| 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 |
| call take_avx_rm |
| jc invalid_operand |
| 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_movd_instruction: |
| or [vex_required],1 |
| jmp movd_instruction |
| avx_movq_instruction: |
| or [vex_required],1 |
| jmp movq_instruction |
| avx_movddup_instruction: |
| or [vex_required],1 |
| mov [opcode_prefix],0F2h |
| 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_avx_register |
| mov [postbyte_register],al |
| mov [mmx_size],0 |
| cmp ah,32 |
| je avx_regs_size_ok |
| mov [mmx_size],8 |
| jmp avx_regs_size_ok |
| avx_movmskpd_instruction: |
| mov [opcode_prefix],66h |
| avx_movmskps_instruction: |
| mov [base_code],0Fh |
| mov [extended_code],50h |
| 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 |
| 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_movsd_instruction: |
| mov [opcode_prefix],0F2h |
| mov [mmx_size],8 |
| jmp avx_movs_instruction |
| avx_movss_instruction: |
| mov [opcode_prefix],0F3h |
| mov [mmx_size],4 |
| avx_movs_instruction: |
| or [vex_required],1 |
| mov [base_code],0Fh |
| mov [extended_code],10h |
| lods byte [esi] |
| call get_size_operator |
| cmp al,10h |
| jne avx_movlps_mem |
| lods byte [esi] |
| call convert_xmm_register |
| mov [postbyte_register],al |
| 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_cvtdq2pd_instruction: |
| mov [opcode_prefix],0F3h |
| avx_cvtps2pd_instruction: |
| mov [base_code],0Fh |
| mov [extended_code],al |
| or [vex_required],1 |
| call take_avx_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 |
| jne avx_cvtdq2pd_reg_mem |
| lods byte [esi] |
| call convert_xmm_register |
| mov bl,al |
| mov [operand_size],cl |
| jmp nomem_instruction_ready |
| avx_cvtdq2pd_reg_mem: |
| cmp al,'[' |
| jne invalid_operand |
| mov [mmx_size],cl |
| call get_address |
| mov al,[operand_size] |
| or al,al |
| jz instruction_ready |
| shl al,1 |
| cmp al,[mmx_size] |
| jne invalid_operand_size |
| mov [operand_size],al |
| jmp instruction_ready |
| avx_cvtpd2dq_instruction: |
| mov [opcode_prefix],0F2h |
| jmp avx_cvtpd_instruction |
| avx_cvtpd2ps_instruction: |
| mov [opcode_prefix],66h |
| avx_cvtpd_instruction: |
| mov [base_code],0Fh |
| mov [extended_code],al |
| or [vex_required],1 |
| call take_avx_register |
| mov [postbyte_register],al |
| cmp ah,16 |
| jne invalid_operand |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| mov [operand_size],0 |
| lods byte [esi] |
| call get_size_operator |
| cmp al,10h |
| jne avx_cvtpd2dq_reg_mem |
| lods byte [esi] |
| call convert_avx_register |
| mov bl,al |
| jmp nomem_instruction_ready |
| avx_cvtpd2dq_reg_mem: |
| cmp al,'[' |
| jne invalid_operand |
| call get_address |
| mov al,[operand_size] |
| or al,al |
| jz operand_size_not_specified |
| cmp al,16 |
| je instruction_ready |
| cmp al,32 |
| jne invalid_operand_size |
| jmp instruction_ready |
| avx_cvttps2dq_instruction: |
| or [vex_required],2 |
| mov [opcode_prefix],0F3h |
| mov [mmx_size],0 |
| jmp avx_instruction |
| avx_cvtsd2si_instruction: |
| or [vex_required],1 |
| jmp cvtsd2si_instruction |
| avx_cvtss2si_instruction: |
| or [vex_required],1 |
| jmp cvtss2si_instruction |
| avx_cvtsi2ss_instruction: |
| mov [opcode_prefix],0F3h |
| jmp avx_cvtsi_instruction |
| avx_cvtsi2sd_instruction: |
| mov [opcode_prefix],0F2h |
| avx_cvtsi_instruction: |
| 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 |
| jmp cvtsi_xmmreg |
| |
| avx_extractf128_instruction: |
| or [vex_required],1 |
| call setup_66_0f_3a |
| lods byte [esi] |
| call get_size_operator |
| cmp al,10h |
| je avx_extractf128_reg |
| cmp al,'[' |
| jne invalid_operand |
| call get_address |
| xor al,al |
| xchg al,[operand_size] |
| or al,al |
| jz avx_extractf128_mem_size_ok |
| cmp al,16 |
| jne invalid_operand_size |
| avx_extractf128_mem_size_ok: |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| call take_avx_register |
| cmp ah,32 |
| jne invalid_operand_size |
| mov [postbyte_register],al |
| jmp mmx_imm8 |
| avx_extractf128_reg: |
| lods byte [esi] |
| call convert_xmm_register |
| mov [operand_size],0 |
| push eax |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| call take_avx_register |
| cmp ah,32 |
| jne invalid_operand_size |
| mov [postbyte_register],al |
| pop ebx |
| jmp mmx_nomem_imm8 |
| avx_insertf128_instruction: |
| or [vex_required],1 |
| call setup_66_0f_3a |
| call take_avx_register |
| cmp ah,32 |
| jne invalid_operand |
| mov [postbyte_register],al |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| call take_avx_register |
| mov [vex_register],al |
| mov [operand_size],0 |
| mov [mmx_size],16 |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| call take_avx_rm |
| mov [operand_size],32 |
| jnc mmx_imm8 |
| mov bl,al |
| jmp mmx_nomem_imm8 |
| avx_extractps_instruction: |
| or [vex_required],1 |
| jmp extractps_instruction |
| avx_insertps_instruction: |
| 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 insertps_xmmreg |
| avx_pextrb_instruction: |
| or [vex_required],1 |
| jmp pextrb_instruction |
| avx_pextrw_instruction: |
| or [vex_required],1 |
| jmp pextrw_instruction |
| avx_pextrd_instruction: |
| or [vex_required],1 |
| jmp pextrd_instruction |
| avx_pextrq_instruction: |
| or [vex_required],1 |
| jmp pextrq_instruction |
| avx_pinsrb_instruction: |
| mov [mmx_size],1 |
| or [vex_required],1 |
| jmp avx_pinsr_instruction_3a |
| avx_pinsrw_instruction: |
| mov [mmx_size],2 |
| or [vex_required],1 |
| jmp avx_pinsr_instruction |
| avx_pinsrd_instruction: |
| mov [mmx_size],4 |
| or [vex_required],1 |
| jmp avx_pinsr_instruction_3a |
| avx_pinsrq_instruction: |
| mov [mmx_size],8 |
| or [vex_required],1 |
| call operand_64bit |
| 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 |
| 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_maskmovdqu_instruction: |
| or [vex_required],1 |
| jmp maskmovdqu_instruction |
| avx_pmovmskb_instruction: |
| or [vex_required],1 |
| jmp pmovmskb_instruction |
| avx_pshufd_instruction: |
| or [vex_required],1 |
| jmp pshufd_instruction |
| avx_pmovsxbw_instruction: |
| mov [mmx_size],8 |
| jmp avx_pmovsx_instruction |
| avx_pmovsxbd_instruction: |
| mov [mmx_size],4 |
| jmp avx_pmovsx_instruction |
| avx_pmovsxbq_instruction: |
| mov [mmx_size],2 |
| jmp avx_pmovsx_instruction |
| avx_pmovsxwd_instruction: |
| mov [mmx_size],8 |
| jmp avx_pmovsx_instruction |
| avx_pmovsxwq_instruction: |
| mov [mmx_size],4 |
| jmp avx_pmovsx_instruction |
| avx_pmovsxdq_instruction: |
| mov [mmx_size],8 |
| avx_pmovsx_instruction: |
| or [vex_required],1 |
| jmp pmovsx_instruction |
| avx_permil_instruction: |
| call setup_66_0f_3a |
| 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,'[' |
| je avx_permil_reg_mem |
| 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 |
| xchg cl,[operand_size] |
| pop esi |
| cmp al,'[' |
| je avx_permil_reg_reg_mem |
| cmp al,10h |
| jne avx_permil_reg_reg_imm8 |
| call take_avx_register |
| mov bl,al |
| mov [extended_code],38h |
| add [supplemental_code],8 |
| jmp nomem_instruction_ready |
| avx_permil_reg_reg_mem: |
| lods byte [esi] |
| call get_size_operator |
| call get_address |
| mov [extended_code],38h |
| add [supplemental_code],8 |
| jmp instruction_ready |
| avx_permil_reg_reg_imm8: |
| dec esi |
| xor bl,bl |
| xchg bl,[vex_register] |
| jmp mmx_nomem_imm8 |
| avx_permil_reg_mem: |
| call get_address |
| jmp mmx_imm8 |
| avx_pslldq_instruction: |
| mov [postbyte_register],al |
| mov [opcode_prefix],66h |
| mov [base_code],0Fh |
| mov [extended_code],73h |
| or [vex_required],1 |
| call take_avx_register |
| cmp ah,16 |
| jne invalid_operand |
| mov [vex_register],al |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| call take_avx_register |
| mov bl,al |
| jmp mmx_nomem_imm8 |
| avx_bit_shift_instruction: |
| mov [opcode_prefix],66h |
| 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 |
| push esi |
| xor cl,cl |
| xchg cl,[operand_size] |
| lods byte [esi] |
| call get_size_operator |
| xchg cl,[operand_size] |
| pop esi |
| cmp al,10h |
| je avx_bit_shift_regs_reg |
| cmp al,'[' |
| je avx_bit_shift_regs_mem |
| dec esi |
| mov bl,[extended_code] |
| mov al,bl |
| shr bl,4 |
| and al,1111b |
| add al,70h |
| mov [extended_code],al |
| sub bl,0Ch |
| shl bl,1 |
| xchg bl,[postbyte_register] |
| xchg bl,[vex_register] |
| jmp mmx_nomem_imm8 |
| avx_bit_shift_regs_reg: |
| call take_avx_register |
| mov bl,al |
| jmp nomem_instruction_ready |
| avx_bit_shift_regs_mem: |
| lods byte [esi] |
| call get_size_operator |
| call get_address |
| jmp instruction_ready |
| |
| vzeroall_instruction: |
| mov [operand_size],32 |
| vzeroupper_instruction: |
| mov [base_code],0Fh |
| mov [extended_code],al |
| or [vex_required],1 |
| call store_instruction_code |
| jmp instruction_assembled |
| vldmxcsr_instruction: |
| or [vex_required],1 |
| jmp fxsave_instruction |
| vcvtph2ps_instruction: |
| mov [opcode_prefix],66h |
| mov [supplemental_code],al |
| mov al,38h |
| jmp avx_cvtps2pd_instruction |
| vcvtps2ph_instruction: |
| call setup_66_0f_3a |
| or [vex_required],1 |
| lods byte [esi] |
| call get_size_operator |
| cmp al,10h |
| je vcvtps2ph_reg |
| cmp al,'[' |
| jne invalid_operand |
| call get_address |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| shl [operand_size],1 |
| call take_avx_register |
| mov [postbyte_register],al |
| jmp mmx_imm8 |
| vcvtps2ph_reg: |
| lods byte [esi] |
| call convert_xmm_register |
| mov bl,al |
| mov [operand_size],0 |
| lods byte [esi] |
| cmp al,',' |
| jne invalid_operand |
| call take_avx_register |
| mov [postbyte_register],al |
| jmp mmx_nomem_imm8 |
| |
| fma_instruction_pd: |
| or [rex_prefix],8 |
| fma_instruction_ps: |
| mov [mmx_size],0 |
| jmp avx_instruction_38_setup |
| fma_instruction_sd: |
| or [rex_prefix],8 |
| mov [mmx_size],8 |
| jmp avx_instruction_38_setup |
| fma_instruction_ss: |
| mov [mmx_size],4 |
| jmp avx_instruction_38_setup |
| |
| fma4_instruction_p: |
| mov [mmx_size],0 |
| jmp fma4_instruction_setup |
| fma4_instruction_sd: |
| mov [mmx_size],8 |
| jmp fma4_instruction_setup |
| fma4_instruction_ss: |
| mov [mmx_size],4 |
| fma4_instruction_setup: |
| mov [immediate_size],-2 |
| mov byte [value],0 |
| jmp avx_instruction_3a_setup |
| |
| xop_single_source_sd_instruction: |
| or [vex_required],2 |
| mov [mmx_size],8 |
| jmp xop_instruction_9 |
| xop_single_source_ss_instruction: |
| or [vex_required],2 |
| mov [mmx_size],4 |
| jmp xop_instruction_9 |
| xop_single_source_instruction: |
| or [vex_required],2 |
| mov [mmx_size],0 |
| xop_instruction_9: |
| mov [base_code],al |
| mov [xop_opcode_map],9 |
| jmp avx_common |
| xop_single_source_128bit_instruction: |
| or [vex_required],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_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 [mmx_size],16 |
| mov [base_code],ah |
| mov [xop_opcode_map],8 |
| jmp avx_common |
| vpcmov_instruction: |
| or [vex_required],1 |
| mov [immediate_size],-2 |
| mov byte [value],0 |
| mov [mmx_size],0 |
| mov [base_code],al |
| mov [xop_opcode_map],8 |
| jmp avx_common |
| xop_shift_instruction: |
| mov [base_code],al |
| or [vex_required],1 |
| 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 |
| |
| 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: |
| mov [base_code],0Fh |
| mov [supplemental_code],al |
| mov al,3Ah |
| mov [mmx_size],0 |
| jmp avx_instruction |
| |
| 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,0Fh |
| and ah,0F0h |
| sub ah,0B0h |
| jbe invalid_operand |
| cmp ah,32 |
| ja invalid_operand |
| cmp al,8 |
| jb match_register_size |
| cmp [code_type],64 |
| jne invalid_operand |
| jmp match_register_size |
| store_vex_instruction_code: |
| mov al,[base_code] |
| cmp al,0Fh |
| jne store_xop_instruction_code |
| 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 vex_l_bit_ok |
| or al,100b |
| vex_l_bit_ok: |
| 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 prefix_conflict |
| 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 |