; flat assembler core ; Copyright (c) 1999-2007, Tomasz Grysztar. ; All rights reserved. simple_instruction_except64: cmp [code_type],64 je illegal_instruction simple_instruction: stos byte [edi] jmp instruction_assembled simple_instruction_only64: cmp [code_type],64 jne illegal_instruction jmp simple_instruction simple_instruction_16bit_except64: cmp [code_type],64 je illegal_instruction simple_instruction_16bit: cmp [code_type],16 jne size_prefix stos byte [edi] jmp instruction_assembled size_prefix: mov ah,al mov al,66h stos word [edi] jmp instruction_assembled simple_instruction_32bit_except64: cmp [code_type],64 je illegal_instruction simple_instruction_32bit: cmp [code_type],16 je size_prefix stos byte [edi] jmp instruction_assembled simple_instruction_64bit: cmp [code_type],64 jne illegal_instruction mov ah,al mov al,48h stos word [edi] jmp instruction_assembled simple_extended_instruction_64bit: cmp [code_type],64 jne illegal_instruction mov al,48h stos byte [edi] simple_extended_instruction: mov ah,al mov al,0Fh stos word [edi] jmp instruction_assembled prefix_instruction: stos byte [edi] or [prefixed_instruction],-1 jmp continue_line segment_prefix: mov ah,al shr ah,4 cmp ah,6 jne illegal_instruction and al,1111b mov [segment_register],al call store_segment_prefix or [prefixed_instruction],-1 jmp continue_line int_instruction: lods byte [esi] call get_size_operator cmp ah,1 ja invalid_operand_size cmp al,'(' jne invalid_operand call get_byte_value mov ah,al mov al,0CDh stos word [edi] jmp instruction_assembled iret_instruction: cmp [code_type],64 jne simple_instruction call operand_64bit jmp simple_instruction aa_instruction: cmp [code_type],64 je illegal_instruction push eax mov bl,10 cmp byte [esi],'(' jne aa_store inc esi xor al,al xchg al,[operand_size] cmp al,1 ja invalid_operand_size call get_byte_value mov bl,al aa_store: cmp [operand_size],0 jne invalid_operand pop eax mov ah,bl stos word [edi] jmp instruction_assembled basic_instruction: mov [base_code],al lods byte [esi] call get_size_operator cmp al,10h je basic_reg cmp al,'[' jne invalid_operand basic_mem: call get_address push edx ebx ecx lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'(' je basic_mem_imm cmp al,10h jne invalid_operand basic_mem_reg: lods byte [esi] call convert_register mov [postbyte_register],al pop ecx ebx edx mov al,ah cmp al,1 je basic_mem_reg_8bit call operand_autodetect inc [base_code] basic_mem_reg_8bit: call store_instruction jmp instruction_assembled basic_mem_imm: mov al,[operand_size] cmp al,1 je basic_mem_imm_8bit cmp al,2 je basic_mem_imm_16bit cmp al,4 je basic_mem_imm_32bit cmp al,8 je basic_mem_imm_64bit or al,al jnz invalid_operand_size cmp [error_line],0 jne basic_mem_imm_8bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified basic_mem_imm_8bit: call get_byte_value mov byte [value],al mov al,[base_code] shr al,3 mov [postbyte_register],al pop ecx ebx edx mov [base_code],80h call store_instruction_with_imm8 jmp instruction_assembled basic_mem_imm_16bit: call operand_16bit call get_word_value mov word [value],ax mov al,[base_code] shr al,3 mov [postbyte_register],al pop ecx ebx edx cmp [value_type],0 jne basic_mem_imm_16bit_store cmp [size_declared],0 jne basic_mem_imm_16bit_store cmp word [value],80h jb basic_mem_simm_8bit cmp word [value],-80h jae basic_mem_simm_8bit basic_mem_imm_16bit_store: mov [base_code],81h call store_instruction_with_imm16 jmp instruction_assembled basic_mem_simm_8bit: mov [base_code],83h call store_instruction_with_imm8 jmp instruction_assembled basic_mem_imm_32bit: call operand_32bit call get_dword_value basic_mem_imm_32bit_ok: mov dword [value],eax mov al,[base_code] shr al,3 mov [postbyte_register],al pop ecx ebx edx cmp [value_type],0 jne basic_mem_imm_32bit_store cmp [size_declared],0 jne basic_mem_imm_32bit_store cmp dword [value],80h jb basic_mem_simm_8bit cmp dword [value],-80h jae basic_mem_simm_8bit basic_mem_imm_32bit_store: mov [base_code],81h call store_instruction_with_imm32 jmp instruction_assembled basic_mem_imm_64bit: cmp [size_declared],0 jne long_immediate_not_encodable call operand_64bit call get_simm32 cmp [value_type],4 jae long_immediate_not_encodable jmp basic_mem_imm_32bit_ok get_simm32: call get_qword_value mov ecx,edx cdq cmp ecx,edx jne value_out_of_range cmp [value_type],4 jne get_simm32_ok mov [value_type],2 get_simm32_ok: ret basic_reg: lods byte [esi] call convert_register mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,10h je basic_reg_reg cmp al,'(' je basic_reg_imm cmp al,'[' jne invalid_operand basic_reg_mem: call get_address mov al,[operand_size] cmp al,1 je basic_reg_mem_8bit call operand_autodetect add [base_code],3 call store_instruction jmp instruction_assembled basic_reg_mem_8bit: add [base_code],2 call store_instruction jmp instruction_assembled basic_reg_reg: lods byte [esi] call convert_register mov bl,[postbyte_register] mov [postbyte_register],al mov al,ah cmp al,1 je basic_reg_reg_8bit call operand_autodetect inc [base_code] basic_reg_reg_8bit: call store_nomem_instruction jmp instruction_assembled basic_reg_imm: mov al,[operand_size] cmp al,1 je basic_reg_imm_8bit cmp al,2 je basic_reg_imm_16bit cmp al,4 je basic_reg_imm_32bit cmp al,8 je basic_reg_imm_64bit or al,al jnz invalid_operand_size cmp [error_line],0 jne basic_reg_imm_32bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified jmp basic_reg_imm_32bit basic_reg_imm_8bit: call get_byte_value mov dl,al mov bl,[base_code] shr bl,3 xchg bl,[postbyte_register] or bl,bl jz basic_al_imm mov [base_code],80h call store_nomem_instruction mov al,dl stos byte [edi] jmp instruction_assembled basic_al_imm: mov al,[base_code] add al,4 stos byte [edi] mov al,dl stos byte [edi] jmp instruction_assembled basic_reg_imm_16bit: call operand_16bit call get_word_value mov dx,ax mov bl,[base_code] shr bl,3 xchg bl,[postbyte_register] cmp [value_type],0 jne basic_reg_imm_16bit_store cmp [size_declared],0 jne basic_reg_imm_16bit_store cmp dx,80h jb basic_reg_simm_8bit cmp dx,-80h jae basic_reg_simm_8bit basic_reg_imm_16bit_store: or bl,bl jz basic_ax_imm mov [base_code],81h call store_nomem_instruction mov ax,dx call mark_relocation stos word [edi] jmp instruction_assembled basic_reg_simm_8bit: mov [base_code],83h call store_nomem_instruction mov al,dl stos byte [edi] jmp instruction_assembled basic_ax_imm: add [base_code],5 call store_instruction_code mov ax,dx call mark_relocation stos word [edi] jmp instruction_assembled basic_reg_imm_32bit: call operand_32bit call get_dword_value basic_reg_imm_32bit_ok: mov edx,eax mov bl,[base_code] shr bl,3 xchg bl,[postbyte_register] cmp [value_type],0 jne basic_reg_imm_32bit_store cmp [size_declared],0 jne basic_reg_imm_32bit_store cmp edx,80h jb basic_reg_simm_8bit cmp edx,-80h jae basic_reg_simm_8bit basic_reg_imm_32bit_store: or bl,bl jz basic_eax_imm mov [base_code],81h call store_nomem_instruction mov eax,edx call mark_relocation stos dword [edi] jmp instruction_assembled basic_eax_imm: add [base_code],5 call store_instruction_code mov eax,edx call mark_relocation stos dword [edi] jmp instruction_assembled basic_reg_imm_64bit: cmp [size_declared],0 jne long_immediate_not_encodable call operand_64bit call get_simm32 cmp [value_type],4 jae long_immediate_not_encodable jmp basic_reg_imm_32bit_ok single_operand_instruction: mov [base_code],0F6h mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,10h je single_reg cmp al,'[' jne invalid_operand single_mem: call get_address mov al,[operand_size] cmp al,1 je single_mem_8bit jb single_mem_nosize call operand_autodetect inc [base_code] call store_instruction jmp instruction_assembled single_mem_nosize: cmp [error_line],0 jne single_mem_8bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified single_mem_8bit: call store_instruction jmp instruction_assembled single_reg: lods byte [esi] call convert_register mov bl,al mov al,ah cmp al,1 je single_reg_8bit call operand_autodetect inc [base_code] single_reg_8bit: call store_nomem_instruction jmp instruction_assembled mov_instruction: mov [base_code],88h lods byte [esi] call get_size_operator cmp al,10h je mov_reg cmp al,'[' jne invalid_operand mov_mem: call get_address push edx ebx ecx lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'(' je mov_mem_imm cmp al,10h jne invalid_operand mov_mem_reg: lods byte [esi] cmp al,60h jb mov_mem_general_reg cmp al,70h jb mov_mem_sreg mov_mem_general_reg: call convert_register mov [postbyte_register],al pop ecx ebx edx cmp ah,1 je mov_mem_reg_8bit mov al,ah call operand_autodetect mov al,[postbyte_register] or al,bl or al,bh jz mov_mem_ax inc [base_code] call store_instruction jmp instruction_assembled mov_mem_reg_8bit: or al,bl or al,bh jz mov_mem_al call store_instruction jmp instruction_assembled mov_mem_al: test ch,22h jnz mov_mem_address16_al test ch,44h jnz mov_mem_address32_al test ch,88h jnz mov_mem_address64_al or ch,ch jnz invalid_address_size cmp [code_type],64 je mov_mem_address64_al cmp [code_type],32 je mov_mem_address32_al cmp edx,10000h jb mov_mem_address16_al mov_mem_address32_al: call store_segment_prefix_if_necessary call address_32bit_prefix mov [base_code],0A2h store_mov_address32: call store_instruction_code push instruction_assembled jmp store_address_32bit_value mov_mem_address16_al: call store_segment_prefix_if_necessary call address_16bit_prefix mov [base_code],0A2h store_mov_address16: cmp [code_type],64 je invalid_address call store_instruction_code mov eax,edx stos word [edi] cmp edx,10000h jge value_out_of_range jmp instruction_assembled mov_mem_address64_al: call store_segment_prefix_if_necessary mov [base_code],0A2h store_mov_address64: call store_instruction_code push instruction_assembled jmp store_address_64bit_value mov_mem_ax: test ch,22h jnz mov_mem_address16_ax test ch,44h jnz mov_mem_address32_ax test ch,88h jnz mov_mem_address64_ax or ch,ch jnz invalid_address_size cmp [code_type],64 je mov_mem_address64_ax cmp [code_type],32 je mov_mem_address32_ax cmp edx,10000h jb mov_mem_address16_ax mov_mem_address32_ax: call store_segment_prefix_if_necessary call address_32bit_prefix mov [base_code],0A3h jmp store_mov_address32 mov_mem_address16_ax: call store_segment_prefix_if_necessary call address_16bit_prefix mov [base_code],0A3h jmp store_mov_address16 mov_mem_address64_ax: call store_segment_prefix_if_necessary mov [base_code],0A3h jmp store_mov_address64 mov_mem_sreg: sub al,61h mov [postbyte_register],al pop ecx ebx edx mov ah,[operand_size] or ah,ah jz mov_mem_sreg_store cmp ah,2 jne invalid_operand_size mov_mem_sreg_store: mov [base_code],8Ch call store_instruction jmp instruction_assembled mov_mem_imm: mov al,[operand_size] cmp al,1 je mov_mem_imm_8bit cmp al,2 je mov_mem_imm_16bit cmp al,4 je mov_mem_imm_32bit cmp al,8 je mov_mem_imm_64bit or al,al jnz invalid_operand_size cmp [error_line],0 jne mov_mem_imm_32bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified jmp mov_mem_imm_32bit mov_mem_imm_8bit: call get_byte_value mov byte [value],al mov [postbyte_register],0 mov [base_code],0C6h pop ecx ebx edx call store_instruction_with_imm8 jmp instruction_assembled mov_mem_imm_16bit: call operand_16bit call get_word_value mov word [value],ax mov [postbyte_register],0 mov [base_code],0C7h pop ecx ebx edx call store_instruction_with_imm16 jmp instruction_assembled mov_mem_imm_32bit: call operand_32bit call get_dword_value mov_mem_imm_32bit_store: mov dword [value],eax mov [postbyte_register],0 mov [base_code],0C7h pop ecx ebx edx call store_instruction_with_imm32 jmp instruction_assembled mov_mem_imm_64bit: cmp [size_declared],0 jne long_immediate_not_encodable call operand_64bit call get_simm32 cmp [value_type],4 jae long_immediate_not_encodable jmp mov_mem_imm_32bit_store mov_reg: lods byte [esi] mov ah,al sub ah,10h and ah,al test ah,0F0h jnz mov_sreg call convert_register mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'[' je mov_reg_mem cmp al,'(' je mov_reg_imm cmp al,10h jne invalid_operand mov_reg_reg: lods byte [esi] mov ah,al sub ah,10h and ah,al test ah,0F0h jnz mov_reg_sreg call convert_register mov bl,[postbyte_register] mov [postbyte_register],al mov al,ah cmp al,1 je mov_reg_reg_8bit call operand_autodetect inc [base_code] mov_reg_reg_8bit: call store_nomem_instruction jmp instruction_assembled mov_reg_sreg: mov bl,[postbyte_register] mov ah,al and al,1111b mov [postbyte_register],al shr ah,4 cmp ah,5 je mov_reg_creg cmp ah,7 je mov_reg_dreg ja mov_reg_treg dec [postbyte_register] cmp [operand_size],8 je mov_reg_sreg64 cmp [operand_size],4 je mov_reg_sreg32 cmp [operand_size],2 jne invalid_operand_size call operand_16bit jmp mov_reg_sreg_store mov_reg_sreg64: call operand_64bit jmp mov_reg_sreg_store mov_reg_sreg32: call operand_32bit mov_reg_sreg_store: mov [base_code],8Ch call store_nomem_instruction jmp instruction_assembled mov_reg_treg: cmp ah,9 jne invalid_operand mov [extended_code],24h jmp mov_reg_xrx mov_reg_dreg: mov [extended_code],21h jmp mov_reg_xrx mov_reg_creg: mov [extended_code],20h mov_reg_xrx: mov [base_code],0Fh cmp [code_type],64 je mov_reg_xrx_64bit cmp [operand_size],4 jne invalid_operand_size cmp [postbyte_register],8 jne mov_reg_xrx_store cmp [extended_code],20h jne mov_reg_xrx_store mov al,0F0h stos byte [edi] mov [postbyte_register],0 mov_reg_xrx_store: call store_nomem_instruction jmp instruction_assembled mov_reg_xrx_64bit: cmp [operand_size],8 jne invalid_operand_size call store_nomem_instruction jmp instruction_assembled mov_reg_mem: call get_address mov al,[operand_size] cmp al,1 je mov_reg_mem_8bit call operand_autodetect mov al,[postbyte_register] or al,bl or al,bh jz mov_ax_mem add [base_code],3 call store_instruction jmp instruction_assembled mov_reg_mem_8bit: mov al,[postbyte_register] or al,bl or al,bh jz mov_al_mem add [base_code],2 call store_instruction jmp instruction_assembled mov_al_mem: test ch,22h jnz mov_al_mem_address16 test ch,44h jnz mov_al_mem_address32 test ch,88h jnz mov_al_mem_address64 or ch,ch jnz invalid_address_size cmp [code_type],64 je mov_al_mem_address64 cmp [code_type],32 je mov_al_mem_address32 cmp edx,10000h jb mov_al_mem_address16 mov_al_mem_address32: call store_segment_prefix_if_necessary call address_32bit_prefix mov [base_code],0A0h jmp store_mov_address32 mov_al_mem_address16: call store_segment_prefix_if_necessary call address_16bit_prefix mov [base_code],0A0h jmp store_mov_address16 mov_al_mem_address64: call store_segment_prefix_if_necessary mov [base_code],0A0h jmp store_mov_address64 mov_ax_mem: test ch,22h jnz mov_ax_mem_address16 test ch,44h jnz mov_ax_mem_address32 test ch,88h jnz mov_ax_mem_address64 or ch,ch jnz invalid_address_size cmp [code_type],64 je mov_ax_mem_address64 cmp [code_type],32 je mov_ax_mem_address32 cmp edx,10000h jb mov_ax_mem_address16 mov_ax_mem_address32: call store_segment_prefix_if_necessary call address_32bit_prefix mov [base_code],0A1h jmp store_mov_address32 mov_ax_mem_address16: call store_segment_prefix_if_necessary call address_16bit_prefix mov [base_code],0A1h jmp store_mov_address16 mov_ax_mem_address64: call store_segment_prefix_if_necessary mov [base_code],0A1h jmp store_mov_address64 mov_reg_imm: mov al,[operand_size] cmp al,1 je mov_reg_imm_8bit cmp al,2 je mov_reg_imm_16bit cmp al,4 je mov_reg_imm_32bit cmp al,8 je mov_reg_imm_64bit or al,al jnz invalid_operand_size cmp [error_line],0 jne mov_reg_imm_32bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified jmp mov_reg_imm_32bit mov_reg_imm_8bit: call get_byte_value mov dl,al mov al,0B0h call store_mov_reg_imm_code mov al,dl stos byte [edi] jmp instruction_assembled mov_reg_imm_16bit: call get_word_value mov dx,ax call operand_16bit mov al,0B8h call store_mov_reg_imm_code mov ax,dx call mark_relocation stos word [edi] jmp instruction_assembled mov_reg_imm_32bit: call operand_32bit call get_dword_value mov edx,eax mov al,0B8h call store_mov_reg_imm_code mov eax,edx call mark_relocation stos dword [edi] jmp instruction_assembled mov_reg_imm_64bit: call operand_64bit call get_qword_value mov ecx,edx cmp [size_declared],0 jne mov_reg_imm_64bit_store cmp [value_type],4 jae mov_reg_imm_64bit_store cdq cmp ecx,edx je mov_reg_64bit_imm_32bit mov_reg_imm_64bit_store: push eax ecx mov al,0B8h call store_mov_reg_imm_code pop edx eax call mark_relocation stos dword [edi] mov eax,edx stos dword [edi] jmp instruction_assembled store_mov_reg_imm_code: mov ah,[postbyte_register] test ah,1000b jz mov_reg_imm_prefix_ok or [rex_prefix],41h mov_reg_imm_prefix_ok: and ah,111b add al,ah mov [base_code],al call store_instruction_code ret mov_reg_64bit_imm_32bit: mov edx,eax mov bl,[postbyte_register] mov [postbyte_register],0 mov [base_code],0C7h call store_nomem_instruction mov eax,edx call mark_relocation stos dword [edi] jmp instruction_assembled mov_sreg: mov ah,al and al,1111b mov [postbyte_register],al shr ah,4 cmp ah,5 je mov_creg cmp ah,7 je mov_dreg ja mov_treg cmp al,2 je illegal_instruction dec [postbyte_register] lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'[' je mov_sreg_mem cmp al,10h jne invalid_operand mov_sreg_reg: lods byte [esi] call convert_register or ah,ah jz mov_sreg_reg_size_ok cmp ah,2 jne invalid_operand_size mov bl,al mov_sreg_reg_size_ok: mov [base_code],8Eh call store_nomem_instruction jmp instruction_assembled mov_sreg_mem: call get_address mov al,[operand_size] or al,al jz mov_sreg_mem_size_ok cmp al,2 jne invalid_operand_size mov_sreg_mem_size_ok: mov [base_code],8Eh call store_instruction jmp instruction_assembled mov_treg: cmp ah,9 jne invalid_operand mov [extended_code],26h jmp mov_xrx mov_dreg: mov [extended_code],23h jmp mov_xrx mov_creg: mov [extended_code],22h mov_xrx: mov [base_code],0Fh lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] cmp al,10h jne invalid_operand lods byte [esi] call convert_register mov bl,al cmp [code_type],64 je mov_xrx_64bit cmp ah,4 jne invalid_operand_size cmp [postbyte_register],8 jne mov_xrx_store cmp [extended_code],22h jne mov_xrx_store mov al,0F0h stos byte [edi] mov [postbyte_register],0 mov_xrx_store: call store_nomem_instruction jmp instruction_assembled mov_xrx_64bit: cmp ah,8 jne invalid_operand_size call store_nomem_instruction jmp instruction_assembled cmov_instruction: 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 mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'[' je cmov_reg_mem cmp al,10h jne invalid_operand cmov_reg_reg: lods byte [esi] call convert_register mov bl,al mov al,ah call operand_autodetect call store_nomem_instruction jmp instruction_assembled cmov_reg_mem: call get_address mov al,[operand_size] call operand_autodetect call store_instruction jmp instruction_assembled test_instruction: mov [base_code],84h lods byte [esi] call get_size_operator cmp al,10h je test_reg cmp al,'[' jne invalid_operand test_mem: call get_address push edx ebx ecx lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'(' je test_mem_imm cmp al,10h jne invalid_operand test_mem_reg: lods byte [esi] call convert_register mov [postbyte_register],al pop ecx ebx edx mov al,ah cmp al,1 je test_mem_reg_8bit call operand_autodetect inc [base_code] test_mem_reg_8bit: call store_instruction jmp instruction_assembled test_mem_imm: mov al,[operand_size] cmp al,1 je test_mem_imm_8bit cmp al,2 je test_mem_imm_16bit cmp al,4 je test_mem_imm_32bit cmp al,8 je test_mem_imm_64bit or al,al jnz invalid_operand_size cmp [error_line],0 jne test_mem_imm_32bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified jmp test_mem_imm_32bit test_mem_imm_8bit: call get_byte_value mov byte [value],al mov [postbyte_register],0 mov [base_code],0F6h pop ecx ebx edx call store_instruction_with_imm8 jmp instruction_assembled test_mem_imm_16bit: call operand_16bit call get_word_value mov word [value],ax mov [postbyte_register],0 mov [base_code],0F7h pop ecx ebx edx call store_instruction_with_imm16 jmp instruction_assembled test_mem_imm_32bit: call operand_32bit call get_dword_value test_mem_imm_32bit_store: mov dword [value],eax mov [postbyte_register],0 mov [base_code],0F7h pop ecx ebx edx call store_instruction_with_imm32 jmp instruction_assembled test_mem_imm_64bit: cmp [size_declared],0 jne long_immediate_not_encodable call operand_64bit call get_simm32 cmp [value_type],4 jae long_immediate_not_encodable jmp test_mem_imm_32bit_store test_reg: lods byte [esi] call convert_register mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'[' je test_reg_mem cmp al,'(' je test_reg_imm cmp al,10h jne invalid_operand test_reg_reg: lods byte [esi] call convert_register mov bl,[postbyte_register] mov [postbyte_register],al mov al,ah cmp al,1 je test_reg_reg_8bit call operand_autodetect inc [base_code] test_reg_reg_8bit: call store_nomem_instruction jmp instruction_assembled test_reg_imm: mov al,[operand_size] cmp al,1 je test_reg_imm_8bit cmp al,2 je test_reg_imm_16bit cmp al,4 je test_reg_imm_32bit cmp al,8 je test_reg_imm_64bit jmp invalid_operand_size test_reg_imm_8bit: call get_byte_value mov dl,al mov bl,[postbyte_register] mov [postbyte_register],0 mov [base_code],0F6h or bl,bl jz test_al_imm call store_nomem_instruction mov al,dl stos byte [edi] jmp instruction_assembled test_al_imm: mov [base_code],0A8h call store_instruction_code mov al,dl stos byte [edi] jmp instruction_assembled test_reg_imm_16bit: call operand_16bit call get_word_value mov dx,ax mov bl,[postbyte_register] mov [postbyte_register],0 mov [base_code],0F7h or bl,bl jz test_ax_imm call store_nomem_instruction mov ax,dx call mark_relocation stos word [edi] jmp instruction_assembled test_ax_imm: mov [base_code],0A9h call store_instruction_code mov ax,dx stos word [edi] jmp instruction_assembled test_reg_imm_32bit: call operand_32bit call get_dword_value test_reg_imm_32bit_store: mov edx,eax mov bl,[postbyte_register] mov [postbyte_register],0 mov [base_code],0F7h or bl,bl jz test_eax_imm call store_nomem_instruction mov eax,edx call mark_relocation stos dword [edi] jmp instruction_assembled test_eax_imm: mov [base_code],0A9h call store_instruction_code mov eax,edx stos dword [edi] jmp instruction_assembled test_reg_imm_64bit: cmp [size_declared],0 jne long_immediate_not_encodable call operand_64bit call get_simm32 cmp [value_type],4 jae long_immediate_not_encodable jmp test_reg_imm_32bit_store test_reg_mem: call get_address mov al,[operand_size] cmp al,1 je test_reg_mem_8bit call operand_autodetect inc [base_code] test_reg_mem_8bit: call store_instruction jmp instruction_assembled xchg_instruction: mov [base_code],86h lods byte [esi] call get_size_operator cmp al,10h je xchg_reg cmp al,'[' jne invalid_operand xchg_mem: call get_address push edx ebx ecx lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,10h je test_mem_reg jmp invalid_operand xchg_reg: lods byte [esi] call convert_register mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'[' je test_reg_mem cmp al,10h jne invalid_operand xchg_reg_reg: lods byte [esi] call convert_register mov bl,al mov al,ah cmp al,1 je xchg_reg_reg_8bit call operand_autodetect cmp [postbyte_register],0 je xchg_ax_reg or bl,bl jnz xchg_reg_reg_store mov bl,[postbyte_register] xchg_ax_reg: cmp [code_type],64 jne xchg_ax_reg_ok cmp ah,4 jne xchg_ax_reg_ok or bl,bl jz xchg_reg_reg_store xchg_ax_reg_ok: test bl,1000b jz xchg_ax_reg_store or [rex_prefix],41h and bl,111b xchg_ax_reg_store: add bl,90h mov [base_code],bl call store_instruction_code jmp instruction_assembled xchg_reg_reg_store: inc [base_code] xchg_reg_reg_8bit: call store_nomem_instruction jmp instruction_assembled push_instruction: mov [push_size],al push_next: lods byte [esi] call get_size_operator cmp al,10h je push_reg cmp al,'(' je push_imm cmp al,'[' jne invalid_operand push_mem: call get_address mov al,[operand_size] mov ah,[push_size] cmp al,2 je push_mem_16bit cmp al,4 je push_mem_32bit cmp al,8 je push_mem_64bit or al,al jnz invalid_operand_size cmp ah,2 je push_mem_16bit cmp ah,4 je push_mem_32bit cmp ah,8 je push_mem_64bit cmp [error_line],0 jne push_mem_store mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified jmp push_mem_store push_mem_16bit: test ah,not 2 jnz invalid_operand_size call operand_16bit jmp push_mem_store push_mem_32bit: test ah,not 4 jnz invalid_operand_size cmp [code_type],64 je illegal_instruction call operand_32bit jmp push_mem_store push_mem_64bit: test ah,not 8 jnz invalid_operand_size cmp [code_type],64 jne illegal_instruction push_mem_store: mov [base_code],0FFh mov [postbyte_register],110b call store_instruction jmp push_done push_reg: lods byte [esi] mov ah,al sub ah,10h and ah,al test ah,0F0h jnz push_sreg call convert_register test al,1000b jz push_reg_ok or [rex_prefix],41h and al,111b push_reg_ok: add al,50h mov [base_code],al mov al,ah mov ah,[push_size] cmp al,2 je push_reg_16bit cmp al,4 je push_reg_32bit cmp al,8 jne invalid_operand_size push_reg_64bit: test ah,not 8 jnz invalid_operand_size cmp [code_type],64 jne illegal_instruction jmp push_reg_store push_reg_32bit: test ah,not 4 jnz invalid_operand_size cmp [code_type],64 je illegal_instruction call operand_32bit jmp push_reg_store push_reg_16bit: test ah,not 2 jnz invalid_operand_size call operand_16bit push_reg_store: call store_instruction_code jmp push_done push_sreg: mov bl,al mov dl,[operand_size] mov dh,[push_size] cmp dl,2 je push_sreg16 cmp dl,4 je push_sreg32 cmp dl,8 je push_sreg64 or dl,dl jnz invalid_operand_size cmp dh,2 je push_sreg16 cmp dh,4 je push_sreg32 cmp dh,8 je push_sreg64 jmp push_sreg_store push_sreg16: test dh,not 2 jnz invalid_operand_size call operand_16bit jmp push_sreg_store push_sreg32: test dh,not 4 jnz invalid_operand_size cmp [code_type],64 je illegal_instruction call operand_32bit jmp push_sreg_store push_sreg64: test dh,not 8 jnz invalid_operand_size cmp [code_type],64 jne illegal_instruction push_sreg_store: mov al,bl cmp al,70h jae invalid_operand sub al,61h jc invalid_operand cmp al,4 jae push_sreg_386 shl al,3 add al,6 mov [base_code],al cmp [code_type],64 je illegal_instruction jmp push_reg_store push_sreg_386: sub al,4 shl al,3 add al,0A0h mov [extended_code],al mov [base_code],0Fh jmp push_reg_store push_imm: mov al,[operand_size] mov ah,[push_size] or al,al je push_imm_size_ok or ah,ah je push_imm_size_ok cmp al,ah jne invalid_operand_size push_imm_size_ok: cmp al,2 je push_imm_16bit cmp al,4 je push_imm_32bit cmp al,8 je push_imm_64bit cmp ah,2 je push_imm_optimized_16bit cmp ah,4 je push_imm_optimized_32bit cmp ah,8 je push_imm_optimized_64bit or al,al jnz invalid_operand_size cmp [code_type],16 je push_imm_optimized_16bit cmp [code_type],32 je push_imm_optimized_32bit push_imm_optimized_64bit: cmp [code_type],64 jne illegal_instruction call get_simm32 mov edx,eax cmp [value_type],0 jne push_imm_32bit_store cmp eax,-80h jl push_imm_32bit_store cmp eax,80h jge push_imm_32bit_store jmp push_imm_8bit push_imm_optimized_32bit: cmp [code_type],64 je illegal_instruction call get_dword_value mov edx,eax call operand_32bit cmp [value_type],0 jne push_imm_32bit_store cmp eax,-80h jl push_imm_32bit_store cmp eax,80h jge push_imm_32bit_store jmp push_imm_8bit push_imm_optimized_16bit: call get_word_value mov dx,ax call operand_16bit cmp [value_type],0 jne push_imm_16bit_store cmp ax,-80h jl push_imm_16bit_store cmp ax,80h jge push_imm_16bit_store push_imm_8bit: mov ah,al mov [base_code],6Ah call store_instruction_code mov al,ah stos byte [edi] jmp push_done push_imm_16bit: call get_word_value mov dx,ax call operand_16bit push_imm_16bit_store: mov [base_code],68h call store_instruction_code mov ax,dx call mark_relocation stos word [edi] jmp push_done push_imm_64bit: cmp [code_type],64 jne illegal_instruction call get_simm32 mov edx,eax jmp push_imm_32bit_store push_imm_32bit: cmp [code_type],64 je illegal_instruction call get_dword_value mov edx,eax call operand_32bit push_imm_32bit_store: mov [base_code],68h call store_instruction_code mov eax,edx call mark_relocation stos dword [edi] push_done: lods byte [esi] dec esi cmp al,0Fh je instruction_assembled or al,al jz instruction_assembled mov [operand_size],0 mov [size_override],0 mov [operand_prefix],0 mov [rex_prefix],0 jmp push_next pop_instruction: mov [push_size],al pop_next: lods byte [esi] call get_size_operator cmp al,10h je pop_reg cmp al,'[' jne invalid_operand pop_mem: call get_address mov al,[operand_size] mov ah,[push_size] cmp al,2 je pop_mem_16bit cmp al,4 je pop_mem_32bit cmp al,8 je pop_mem_64bit or al,al jnz invalid_operand_size cmp ah,2 je pop_mem_16bit cmp ah,4 je pop_mem_32bit cmp ah,8 je pop_mem_64bit cmp [error_line],0 jne pop_mem_store mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified jmp pop_mem_store pop_mem_16bit: test ah,not 2 jnz invalid_operand_size call operand_16bit jmp pop_mem_store pop_mem_32bit: test ah,not 4 jnz invalid_operand_size cmp [code_type],64 je illegal_instruction call operand_32bit jmp pop_mem_store pop_mem_64bit: test ah,not 8 jnz invalid_operand_size cmp [code_type],64 jne illegal_instruction pop_mem_store: mov [base_code],08Fh mov [postbyte_register],0 call store_instruction jmp pop_done pop_reg: lods byte [esi] mov ah,al sub ah,10h and ah,al test ah,0F0h jnz pop_sreg call convert_register test al,1000b jz pop_reg_ok or [rex_prefix],41h and al,111b pop_reg_ok: add al,58h mov [base_code],al mov al,ah mov ah,[push_size] cmp al,2 je pop_reg_16bit cmp al,4 je pop_reg_32bit cmp al,8 je pop_reg_64bit jmp invalid_operand_size pop_reg_64bit: test ah,not 8 jnz invalid_operand_size cmp [code_type],64 jne illegal_instruction jmp pop_reg_store pop_reg_32bit: test ah,not 4 jnz invalid_operand_size cmp [code_type],64 je illegal_instruction call operand_32bit jmp pop_reg_store pop_reg_16bit: test ah,not 2 jnz invalid_operand_size call operand_16bit pop_reg_store: call store_instruction_code pop_done: lods byte [esi] dec esi cmp al,0Fh je instruction_assembled or al,al jz instruction_assembled mov [operand_size],0 mov [size_override],0 mov [operand_prefix],0 mov [rex_prefix],0 jmp pop_next pop_sreg: mov dl,[operand_size] mov dh,[push_size] cmp al,62h je pop_cs mov bl,al cmp dl,2 je pop_sreg16 cmp dl,4 je pop_sreg32 cmp dl,8 je pop_sreg64 or dl,dl jnz invalid_operand_size cmp dh,2 je pop_sreg16 cmp dh,4 je pop_sreg32 cmp dh,8 je pop_sreg64 jmp pop_sreg_store pop_sreg16: test dh,not 2 jnz invalid_operand_size call operand_16bit jmp pop_sreg_store pop_sreg32: test dh,not 4 jnz invalid_operand_size cmp [code_type],64 je illegal_instruction call operand_32bit jmp pop_sreg_store pop_sreg64: test dh,not 8 jnz invalid_operand_size cmp [code_type],64 jne illegal_instruction pop_sreg_store: mov al,bl cmp al,70h jae invalid_operand sub al,61h jc invalid_operand cmp al,4 jae pop_sreg_386 shl al,3 add al,7 mov [base_code],al cmp [code_type],64 je illegal_instruction jmp pop_reg_store pop_cs: cmp [code_type],16 jne illegal_instruction cmp dl,2 je pop_cs_store or dl,dl jnz invalid_operand_size cmp dh,2 je pop_cs_store or dh,dh jnz illegal_instruction pop_cs_store: test dh,not 2 jnz invalid_operand_size mov al,0Fh stos byte [edi] jmp pop_done pop_sreg_386: sub al,4 shl al,3 add al,0A1h mov [extended_code],al mov [base_code],0Fh jmp pop_reg_store inc_instruction: mov [base_code],al lods byte [esi] call get_size_operator cmp al,10h je inc_reg cmp al,'[' je inc_mem jne invalid_operand inc_mem: call get_address mov al,[operand_size] cmp al,1 je inc_mem_8bit jb inc_mem_nosize call operand_autodetect mov al,0FFh xchg al,[base_code] mov [postbyte_register],al call store_instruction jmp instruction_assembled inc_mem_nosize: cmp [error_line],0 jne inc_mem_8bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified inc_mem_8bit: mov al,0FEh xchg al,[base_code] mov [postbyte_register],al call store_instruction jmp instruction_assembled inc_reg: lods byte [esi] call convert_register mov bl,al mov al,0FEh xchg al,[base_code] mov [postbyte_register],al mov al,ah cmp al,1 je inc_reg_8bit call operand_autodetect cmp [code_type],64 je inc_reg_long_form mov al,[postbyte_register] shl al,3 add al,bl add al,40h mov [base_code],al call store_instruction_code jmp instruction_assembled inc_reg_long_form: inc [base_code] inc_reg_8bit: call store_nomem_instruction jmp instruction_assembled set_instruction: mov [base_code],0Fh mov [extended_code],al lods byte [esi] call get_size_operator cmp al,10h je set_reg cmp al,'[' jne invalid_operand set_mem: call get_address cmp [operand_size],1 ja invalid_operand_size mov [postbyte_register],0 call store_instruction jmp instruction_assembled set_reg: lods byte [esi] call convert_register cmp ah,1 jne invalid_operand_size mov bl,al mov [postbyte_register],0 call store_nomem_instruction jmp instruction_assembled arpl_instruction: cmp [code_type],64 je illegal_instruction mov [base_code],63h lods byte [esi] call get_size_operator cmp al,10h je arpl_reg cmp al,'[' jne invalid_operand call get_address lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] cmp al,10h jne invalid_operand lods byte [esi] call convert_register mov [postbyte_register],al cmp ah,2 jne invalid_operand_size call store_instruction jmp instruction_assembled arpl_reg: lods byte [esi] call convert_register cmp ah,2 jne invalid_operand_size mov bl,al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] cmp al,10h jne invalid_operand lods byte [esi] call convert_register cmp ah,2 jne invalid_operand_size mov [postbyte_register],al call store_nomem_instruction jmp instruction_assembled bound_instruction: cmp [code_type],64 je illegal_instruction 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 lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] cmp al,2 je bound_16bit cmp al,4 je bound_32bit jmp invalid_operand_size bound_32bit: call operand_32bit mov [base_code],62h call store_instruction jmp instruction_assembled bound_16bit: call operand_16bit mov [base_code],62h call store_instruction jmp instruction_assembled enter_instruction: lods byte [esi] call get_size_operator cmp ah,2 je enter_imm16_size_ok or ah,ah jnz invalid_operand_size enter_imm16_size_ok: cmp al,'(' jne invalid_operand call get_word_value cmp [next_pass_needed],0 jne enter_imm16_ok cmp [value_type],0 jne invalid_use_of_symbol enter_imm16_ok: push eax mov [operand_size],0 lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp ah,1 je enter_imm8_size_ok or ah,ah jnz invalid_operand_size enter_imm8_size_ok: cmp al,'(' jne invalid_operand call get_byte_value mov dl,al pop ebx mov al,0C8h stos byte [edi] mov ax,bx stos word [edi] mov al,dl stos byte [edi] jmp instruction_assembled ret_instruction_only64: cmp [code_type],64 jne illegal_instruction jmp ret_instruction ret_instruction_32bit_except64: cmp [code_type],64 je illegal_instruction ret_instruction_32bit: call operand_32bit jmp ret_instruction ret_instruction_16bit: call operand_16bit jmp ret_instruction retf_instruction: cmp [code_type],64 jne ret_instruction ret_instruction_64bit: call operand_64bit ret_instruction: mov [base_code],al lods byte [esi] dec esi or al,al jz simple_ret cmp al,0Fh je simple_ret lods byte [esi] call get_size_operator or ah,ah jz ret_imm cmp ah,2 je ret_imm jmp invalid_operand_size ret_imm: cmp al,'(' jne invalid_operand call get_word_value cmp [next_pass_needed],0 jne ret_imm_ok cmp [value_type],0 jne invalid_use_of_symbol ret_imm_ok: cmp [size_declared],0 jne ret_imm_store or ax,ax jz simple_ret ret_imm_store: mov dx,ax call store_instruction_code mov ax,dx stos word [edi] jmp instruction_assembled simple_ret: inc [base_code] call store_instruction_code jmp instruction_assembled lea_instruction: mov [base_code],8Dh 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 al,al xchg al,[operand_size] push eax lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand mov [size_override],-1 call get_address pop eax mov [operand_size],al call operand_autodetect call store_instruction jmp instruction_assembled ls_instruction: or al,al jz les_instruction cmp al,3 jz lds_instruction add al,0B0h mov [extended_code],al mov [base_code],0Fh jmp ls_code_ok les_instruction: mov [base_code],0C4h jmp ls_short_code lds_instruction: mov [base_code],0C5h ls_short_code: cmp [code_type],64 je illegal_instruction ls_code_ok: 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 add [operand_size],2 lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] cmp al,4 je ls_16bit cmp al,6 je ls_32bit cmp al,10 je ls_64bit jmp invalid_operand_size ls_16bit: call operand_16bit call store_instruction jmp instruction_assembled ls_32bit: call operand_32bit call store_instruction jmp instruction_assembled ls_64bit: call operand_64bit call store_instruction jmp instruction_assembled sh_instruction: mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,10h je sh_reg cmp al,'[' jne invalid_operand sh_mem: call get_address push edx ebx ecx mov al,[operand_size] push eax mov [operand_size],0 lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'(' je sh_mem_imm cmp al,10h jne invalid_operand sh_mem_reg: lods byte [esi] cmp al,11h jne invalid_operand pop eax ecx ebx edx cmp al,1 je sh_mem_cl_8bit jb sh_mem_cl_nosize call operand_autodetect mov [base_code],0D3h call store_instruction jmp instruction_assembled sh_mem_cl_nosize: cmp [error_line],0 jne sh_mem_cl_8bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified sh_mem_cl_8bit: mov [base_code],0D2h call store_instruction jmp instruction_assembled sh_mem_imm: mov al,[operand_size] or al,al jz sh_mem_imm_size_ok cmp al,1 jne invalid_operand_size sh_mem_imm_size_ok: call get_byte_value mov byte [value],al pop eax ecx ebx edx cmp al,1 je sh_mem_imm_8bit jb sh_mem_imm_nosize call operand_autodetect cmp byte [value],1 je sh_mem_1 mov [base_code],0C1h call store_instruction_with_imm8 jmp instruction_assembled sh_mem_1: mov [base_code],0D1h call store_instruction jmp instruction_assembled sh_mem_imm_nosize: cmp [error_line],0 jne sh_mem_imm_8bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified sh_mem_imm_8bit: cmp byte [value],1 je sh_mem_1_8bit mov [base_code],0C0h call store_instruction_with_imm8 jmp instruction_assembled sh_mem_1_8bit: mov [base_code],0D0h call store_instruction jmp instruction_assembled sh_reg: lods byte [esi] call convert_register mov bx,ax mov [operand_size],0 lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'(' je sh_reg_imm cmp al,10h jne invalid_operand sh_reg_reg: lods byte [esi] cmp al,11h jne invalid_operand mov al,bh cmp al,1 je sh_reg_cl_8bit call operand_autodetect mov [base_code],0D3h call store_nomem_instruction jmp instruction_assembled sh_reg_cl_8bit: mov [base_code],0D2h call store_nomem_instruction jmp instruction_assembled sh_reg_imm: mov al,[operand_size] or al,al jz sh_reg_imm_size_ok cmp al,1 jne invalid_operand_size sh_reg_imm_size_ok: push ebx call get_byte_value mov dl,al pop ebx mov al,bh cmp al,1 je sh_reg_imm_8bit call operand_autodetect cmp dl,1 je sh_reg_1 mov [base_code],0C1h call store_nomem_instruction mov al,dl stos byte [edi] jmp instruction_assembled sh_reg_1: mov [base_code],0D1h call store_nomem_instruction jmp instruction_assembled sh_reg_imm_8bit: cmp dl,1 je sh_reg_1_8bit mov [base_code],0C0h call store_nomem_instruction mov al,dl stos byte [edi] jmp instruction_assembled sh_reg_1_8bit: mov [base_code],0D0h call store_nomem_instruction jmp instruction_assembled shd_instruction: mov [base_code],0Fh mov [extended_code],al lods byte [esi] call get_size_operator cmp al,10h je shd_reg cmp al,'[' jne invalid_operand shd_mem: call get_address push edx ebx ecx 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_register mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand mov al,ah mov [operand_size],0 push eax lods byte [esi] call get_size_operator cmp al,'(' je shd_mem_reg_imm cmp al,10h jne invalid_operand lods byte [esi] cmp al,11h jne invalid_operand pop eax ecx ebx edx call operand_autodetect inc [extended_code] call store_instruction jmp instruction_assembled shd_mem_reg_imm: mov al,[operand_size] or al,al jz shd_mem_reg_imm_size_ok cmp al,1 jne invalid_operand_size shd_mem_reg_imm_size_ok: call get_byte_value mov byte [value],al pop eax ecx ebx edx call operand_autodetect call store_instruction_with_imm8 jmp instruction_assembled shd_reg: lods byte [esi] call convert_register mov [postbyte_register],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_register mov bl,[postbyte_register] mov [postbyte_register],al mov al,ah push eax ebx lods byte [esi] cmp al,',' jne invalid_operand mov [operand_size],0 lods byte [esi] call get_size_operator cmp al,'(' je shd_reg_reg_imm cmp al,10h jne invalid_operand lods byte [esi] cmp al,11h jne invalid_operand pop ebx eax call operand_autodetect inc [extended_code] call store_nomem_instruction jmp instruction_assembled shd_reg_reg_imm: mov al,[operand_size] or al,al jz shd_reg_reg_imm_size_ok cmp al,1 jne invalid_operand_size shd_reg_reg_imm_size_ok: call get_byte_value mov dl,al pop ebx eax call operand_autodetect call store_nomem_instruction mov al,dl stos byte [edi] jmp instruction_assembled movx_instruction: 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 mov [postbyte_register],al mov al,ah push eax lods byte [esi] cmp al,',' jne invalid_operand mov [operand_size],0 lods byte [esi] call get_size_operator cmp al,10h je movx_reg cmp al,'[' jne invalid_operand call get_address pop eax mov ah,[operand_size] or ah,ah jz movx_unknown_size cmp ah,al jae invalid_operand_size cmp ah,1 je movx_mem_8bit cmp ah,2 jne invalid_operand_size movx_mem_16bit: inc [extended_code] call operand_autodetect call store_instruction jmp instruction_assembled movx_unknown_size: cmp [error_line],0 jne movx_mem_8bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified movx_mem_8bit: call operand_autodetect call store_instruction jmp instruction_assembled movx_reg: lods byte [esi] call convert_register pop ebx xchg bl,al cmp ah,al jae invalid_operand_size cmp ah,1 je movx_reg_8bit cmp ah,2 je movx_reg_16bit jmp invalid_operand_size movx_reg_8bit: call operand_autodetect call store_nomem_instruction jmp instruction_assembled movx_reg_16bit: call operand_autodetect inc [extended_code] call store_nomem_instruction jmp instruction_assembled movsxd_instruction: mov [base_code],al 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,8 jne invalid_operand_size lods byte [esi] cmp al,',' jne invalid_operand mov [operand_size],0 lods byte [esi] call get_size_operator cmp al,10h je movsxd_reg cmp al,'[' jne invalid_operand call get_address cmp [operand_size],4 je movsxd_mem_store cmp [operand_size],0 jne invalid_operand_size movsxd_mem_store: call operand_64bit call store_instruction jmp instruction_assembled movsxd_reg: lods byte [esi] call convert_register cmp ah,4 jne invalid_operand_size mov bl,al call operand_64bit call store_nomem_instruction jmp instruction_assembled bt_instruction: mov [postbyte_register],al shl al,3 add al,83h mov [extended_code],al mov [base_code],0Fh lods byte [esi] call get_size_operator cmp al,10h je bt_reg cmp al,'[' jne invalid_operand call get_address push eax ebx ecx lods byte [esi] cmp al,',' jne invalid_operand cmp byte [esi],'(' je bt_mem_imm cmp byte [esi],11h jne bt_mem_reg cmp byte [esi+2],'(' je bt_mem_imm bt_mem_reg: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register mov [postbyte_register],al pop ecx ebx edx mov al,ah call operand_autodetect call store_instruction jmp instruction_assembled bt_mem_imm: xor al,al xchg al,[operand_size] push eax lods byte [esi] call get_size_operator cmp al,'(' jne invalid_operand mov al,[operand_size] or al,al jz bt_mem_imm_size_ok cmp al,1 jne invalid_operand_size bt_mem_imm_size_ok: call get_byte_value mov byte [value],al pop eax or al,al jz bt_mem_imm_nosize call operand_autodetect bt_mem_imm_store: pop ecx ebx edx mov [extended_code],0BAh call store_instruction_with_imm8 jmp instruction_assembled bt_mem_imm_nosize: cmp [error_line],0 jne bt_mem_imm_store mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified jmp bt_mem_imm_store bt_reg: lods byte [esi] call convert_register mov bl,al lods byte [esi] cmp al,',' jne invalid_operand cmp byte [esi],'(' je bt_reg_imm cmp byte [esi],11h jne bt_reg_reg cmp byte [esi+2],'(' je bt_reg_imm bt_reg_reg: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register mov [postbyte_register],al mov al,ah call operand_autodetect call store_nomem_instruction jmp instruction_assembled bt_reg_imm: xor al,al xchg al,[operand_size] push eax ebx lods byte [esi] call get_size_operator cmp al,'(' jne invalid_operand mov al,[operand_size] or al,al jz bt_reg_imm_size_ok cmp al,1 jne invalid_operand_size bt_reg_imm_size_ok: call get_byte_value mov byte [value],al pop ebx eax call operand_autodetect bt_reg_imm_store: mov [extended_code],0BAh call store_nomem_instruction mov al,byte [value] stos byte [edi] jmp instruction_assembled bs_instruction: mov [extended_code],al mov [base_code],0Fh 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 lods byte [esi] call get_size_operator cmp al,10h je bs_reg_reg cmp al,'[' jne invalid_argument call get_address mov al,[operand_size] call operand_autodetect call store_instruction jmp instruction_assembled bs_reg_reg: lods byte [esi] call convert_register mov bl,al mov al,ah call operand_autodetect call store_nomem_instruction jmp instruction_assembled imul_instruction: mov [base_code],0F6h mov [postbyte_register],5 lods byte [esi] call get_size_operator cmp al,10h je imul_reg cmp al,'[' jne invalid_operand imul_mem: call get_address mov al,[operand_size] cmp al,1 je imul_mem_8bit jb imul_mem_nosize call operand_autodetect inc [base_code] call store_instruction jmp instruction_assembled imul_mem_nosize: cmp [error_line],0 jne imul_mem_8bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified imul_mem_8bit: call store_instruction jmp instruction_assembled imul_reg: lods byte [esi] call convert_register cmp byte [esi],',' je imul_reg_ mov bl,al mov al,ah cmp al,1 je imul_reg_8bit call operand_autodetect inc [base_code] call store_nomem_instruction jmp instruction_assembled imul_reg_8bit: call store_nomem_instruction jmp instruction_assembled imul_reg_: mov [postbyte_register],al inc esi cmp byte [esi],'(' je imul_reg_imm cmp byte [esi],11h jne imul_reg_noimm cmp byte [esi+2],'(' je imul_reg_imm imul_reg_noimm: lods byte [esi] call get_size_operator cmp al,10h je imul_reg_reg cmp al,'[' jne invalid_operand imul_reg_mem: call get_address push edx ebx ecx cmp byte [esi],',' je imul_reg_mem_imm mov al,[operand_size] call operand_autodetect pop ecx ebx edx mov [base_code],0Fh mov [extended_code],0AFh call store_instruction jmp instruction_assembled imul_reg_mem_imm: inc esi lods byte [esi] call get_size_operator cmp al,'(' jne invalid_operand mov al,[operand_size] cmp al,2 je imul_reg_mem_imm_16bit cmp al,4 je imul_reg_mem_imm_32bit cmp al,8 je imul_reg_mem_imm_64bit jmp invalid_operand_size imul_reg_mem_imm_16bit: call operand_16bit call get_word_value mov word [value],ax cmp [value_type],0 jne imul_reg_mem_imm_16bit_store cmp [size_declared],0 jne imul_reg_mem_imm_16bit_store cmp ax,-80h jl imul_reg_mem_imm_16bit_store cmp ax,80h jl imul_reg_mem_imm_8bit_store imul_reg_mem_imm_16bit_store: pop ecx ebx edx mov [base_code],69h call store_instruction_with_imm16 jmp instruction_assembled imul_reg_mem_imm_32bit: call operand_32bit call get_dword_value imul_reg_mem_imm_32bit_ok: mov dword [value],eax cmp [value_type],0 jne imul_reg_mem_imm_32bit_store cmp [size_declared],0 jne imul_reg_mem_imm_32bit_store cmp eax,-80h jl imul_reg_mem_imm_32bit_store cmp eax,80h jl imul_reg_mem_imm_8bit_store imul_reg_mem_imm_32bit_store: pop ecx ebx edx mov [base_code],69h call store_instruction_with_imm32 jmp instruction_assembled imul_reg_mem_imm_64bit: cmp [size_declared],0 jne long_immediate_not_encodable call operand_64bit call get_simm32 cmp [value_type],4 jae long_immediate_not_encodable jmp imul_reg_mem_imm_32bit_ok imul_reg_mem_imm_8bit_store: pop ecx ebx edx mov [base_code],6Bh call store_instruction_with_imm8 jmp instruction_assembled imul_reg_imm: mov bl,[postbyte_register] dec esi jmp imul_reg_reg_imm imul_reg_reg: lods byte [esi] call convert_register mov bl,al cmp byte [esi],',' je imul_reg_reg_imm mov al,ah call operand_autodetect mov [base_code],0Fh mov [extended_code],0AFh call store_nomem_instruction jmp instruction_assembled imul_reg_reg_imm: inc esi lods byte [esi] call get_size_operator cmp al,'(' jne invalid_operand mov al,[operand_size] cmp al,2 je imul_reg_reg_imm_16bit cmp al,4 je imul_reg_reg_imm_32bit cmp al,8 je imul_reg_reg_imm_64bit jmp invalid_operand_size imul_reg_reg_imm_16bit: call operand_16bit push ebx call get_word_value pop ebx mov dx,ax cmp [value_type],0 jne imul_reg_reg_imm_16bit_store cmp [size_declared],0 jne imul_reg_reg_imm_16bit_store cmp ax,-80h jl imul_reg_reg_imm_16bit_store cmp ax,80h jl imul_reg_reg_imm_8bit_store imul_reg_reg_imm_16bit_store: mov [base_code],69h call store_nomem_instruction mov ax,dx call mark_relocation stos word [edi] jmp instruction_assembled imul_reg_reg_imm_32bit: call operand_32bit push ebx call get_dword_value imul_reg_reg_imm_32bit_ok: pop ebx mov edx,eax cmp [value_type],0 jne imul_reg_reg_imm_32bit_store cmp [size_declared],0 jne imul_reg_reg_imm_32bit_store cmp eax,-80h jl imul_reg_reg_imm_32bit_store cmp eax,80h jl imul_reg_reg_imm_8bit_store imul_reg_reg_imm_32bit_store: mov [base_code],69h call store_nomem_instruction mov eax,edx call mark_relocation stos dword [edi] jmp instruction_assembled imul_reg_reg_imm_64bit: cmp [size_declared],0 jne long_immediate_not_encodable call operand_64bit push ebx call get_simm32 cmp [value_type],4 jae long_immediate_not_encodable jmp imul_reg_reg_imm_32bit_ok imul_reg_reg_imm_8bit_store: mov [base_code],6Bh call store_nomem_instruction mov al,dl stos byte [edi] jmp instruction_assembled in_instruction: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register or al,al jnz invalid_operand lods byte [esi] cmp al,',' jne invalid_operand mov al,ah push eax mov [operand_size],0 lods byte [esi] call get_size_operator cmp al,'(' je in_imm cmp al,10h je in_reg jmp invalid_operand in_reg: lods byte [esi] cmp al,22h jne invalid_operand pop eax cmp al,1 je in_al_dx cmp al,2 je in_ax_dx cmp al,4 je in_eax_dx jmp invalid_operand_size in_al_dx: mov al,0ECh stos byte [edi] jmp instruction_assembled in_ax_dx: call operand_16bit mov [base_code],0EDh call store_instruction_code jmp instruction_assembled in_eax_dx: call operand_32bit mov [base_code],0EDh call store_instruction_code jmp instruction_assembled in_imm: mov al,[operand_size] or al,al jz in_imm_size_ok cmp al,1 jne invalid_operand_size in_imm_size_ok: call get_byte_value mov dl,al pop eax cmp al,1 je in_al_imm cmp al,2 je in_ax_imm cmp al,4 je in_eax_imm jmp invalid_operand_size in_al_imm: mov al,0E4h stos byte [edi] mov al,dl stos byte [edi] jmp instruction_assembled in_ax_imm: call operand_16bit mov [base_code],0E5h call store_instruction_code mov al,dl stos byte [edi] jmp instruction_assembled in_eax_imm: call operand_32bit mov [base_code],0E5h call store_instruction_code mov al,dl stos byte [edi] jmp instruction_assembled out_instruction: lods byte [esi] call get_size_operator cmp al,'(' je out_imm cmp al,10h jne invalid_operand lods byte [esi] cmp al,22h 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 invalid_operand lods byte [esi] call convert_register or al,al jnz invalid_operand mov al,ah cmp al,1 je out_dx_al cmp al,2 je out_dx_ax cmp al,4 je out_dx_eax jmp invalid_operand_size out_dx_al: mov al,0EEh stos byte [edi] jmp instruction_assembled out_dx_ax: call operand_16bit mov [base_code],0EFh call store_instruction_code jmp instruction_assembled out_dx_eax: call operand_32bit mov [base_code],0EFh call store_instruction_code jmp instruction_assembled out_imm: mov al,[operand_size] or al,al jz out_imm_size_ok cmp al,1 jne invalid_operand_size out_imm_size_ok: call get_byte_value mov dl,al lods byte [esi] cmp al,',' jne invalid_operand mov [operand_size],0 lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register or al,al jnz invalid_operand mov al,ah cmp al,1 je out_imm_al cmp al,2 je out_imm_ax cmp al,4 je out_imm_eax jmp invalid_operand_size out_imm_al: mov al,0E6h stos byte [edi] mov al,dl stos byte [edi] jmp instruction_assembled out_imm_ax: call operand_16bit mov [base_code],0E7h call store_instruction_code mov al,dl stos byte [edi] jmp instruction_assembled out_imm_eax: call operand_32bit mov [base_code],0E7h call store_instruction_code mov al,dl stos byte [edi] jmp instruction_assembled call_instruction: mov [postbyte_register],10b mov [base_code],0E8h mov [extended_code],9Ah jmp process_jmp jmp_instruction: mov [postbyte_register],100b mov [base_code],0E9h mov [extended_code],0EAh process_jmp: lods byte [esi] call get_jump_operator call get_size_operator cmp al,'(' je jmp_imm mov [base_code],0FFh cmp al,10h je jmp_reg cmp al,'[' jne invalid_operand jmp_mem: cmp [jump_type],1 je illegal_instruction call get_address mov edx,eax mov al,[operand_size] or al,al jz jmp_mem_size_not_specified cmp al,2 je jmp_mem_16bit cmp al,4 je jmp_mem_32bit cmp al,6 je jmp_mem_48bit cmp al,8 je jmp_mem_64bit cmp al,10 je jmp_mem_80bit jmp invalid_operand_size jmp_mem_size_not_specified: cmp [jump_type],3 je jmp_mem_far cmp [jump_type],2 je jmp_mem_near cmp [error_line],0 jne jmp_mem_near mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified jmp_mem_near: cmp [code_type],16 je jmp_mem_16bit cmp [code_type],32 je jmp_mem_near_32bit jmp_mem_64bit: cmp [jump_type],3 je invalid_operand_size cmp [code_type],64 jne illegal_instruction call store_instruction jmp instruction_assembled jmp_mem_far: cmp [code_type],16 je jmp_mem_far_32bit jmp_mem_48bit: call operand_32bit jmp_mem_far_store: cmp [jump_type],2 je invalid_operand_size inc [postbyte_register] call store_instruction jmp instruction_assembled jmp_mem_80bit: call operand_64bit jmp jmp_mem_far_store jmp_mem_far_32bit: call operand_16bit jmp jmp_mem_far_store jmp_mem_32bit: cmp [jump_type],3 je jmp_mem_far_32bit cmp [jump_type],2 je jmp_mem_near_32bit cmp [code_type],16 je jmp_mem_far_32bit jmp_mem_near_32bit: cmp [code_type],64 je illegal_instruction call operand_32bit call store_instruction jmp instruction_assembled jmp_mem_16bit: cmp [jump_type],3 je invalid_operand_size call operand_16bit call store_instruction jmp instruction_assembled jmp_reg: test [jump_type],1 jnz invalid_operand lods byte [esi] call convert_register mov bl,al mov al,ah cmp al,2 je jmp_reg_16bit cmp al,4 je jmp_reg_32bit cmp al,8 jne invalid_operand_size jmp_reg_64bit: cmp [code_type],64 jne illegal_instruction call store_nomem_instruction jmp instruction_assembled jmp_reg_32bit: cmp [code_type],64 je illegal_instruction call store_nomem_instruction jmp instruction_assembled jmp_reg_16bit: call operand_16bit call store_nomem_instruction jmp instruction_assembled jmp_imm: cmp byte [esi],'.' je invalid_value mov ebx,esi dec esi call skip_symbol xchg esi,ebx cmp byte [ebx],':' je jmp_far cmp [jump_type],3 je invalid_operand jmp_near: mov al,[operand_size] cmp al,2 je jmp_imm_16bit cmp al,4 je jmp_imm_32bit cmp al,8 je jmp_imm_64bit or al,al jnz invalid_operand_size cmp [code_type],16 je jmp_imm_16bit cmp [code_type],64 je jmp_imm_64bit jmp_imm_32bit: cmp [code_type],64 je invalid_operand_size call get_address_dword_value cmp [code_type],16 jne jmp_imm_32bit_prefix_ok mov byte [edi],66h inc edi jmp_imm_32bit_prefix_ok: call calculate_jump_offset cdq call check_for_short_jump jc jmp_short jmp_imm_32bit_store: mov edx,eax sub edx,3 mov al,[base_code] stos byte [edi] mov eax,edx call mark_relocation stos dword [edi] jmp instruction_assembled jmp_imm_64bit: cmp [code_type],64 jne invalid_operand_size call get_address_qword_value call calculate_jump_offset mov ecx,edx cdq cmp edx,ecx jne value_out_of_range call check_for_short_jump jnc jmp_imm_32bit_store jmp_short: mov ah,al mov al,0EBh stos word [edi] jmp instruction_assembled jmp_imm_16bit: call get_address_word_value cmp [code_type],16 je jmp_imm_16bit_prefix_ok mov byte [edi],66h inc edi jmp_imm_16bit_prefix_ok: call calculate_jump_offset cwde cdq call check_for_short_jump jc jmp_short cmp [value_type],0 jne invalid_use_of_symbol mov edx,eax dec edx mov al,[base_code] stos byte [edi] mov eax,edx stos word [edi] jmp instruction_assembled calculate_jump_offset: add edi,2 call calculate_relative_offset sub edi,2 ret check_for_short_jump: cmp [jump_type],1 je forced_short ja no_short_jump cmp [base_code],0E8h je no_short_jump cmp [value_type],0 jne no_short_jump cmp eax,80h jb short_jump cmp eax,-80h jae short_jump no_short_jump: clc ret forced_short: cmp [base_code],0E8h je illegal_instruction cmp [next_pass_needed],0 jne jmp_short_value_type_ok cmp [value_type],0 jne invalid_use_of_symbol jmp_short_value_type_ok: cmp eax,-80h jae short_jump cmp eax,80h jae jump_out_of_range short_jump: stc ret jump_out_of_range: cmp [error_line],0 jne instruction_assembled mov eax,[current_line] mov [error_line],eax mov [error],relative_jump_out_of_range jmp instruction_assembled jmp_far: cmp [jump_type],2 je invalid_operand cmp [code_type],64 je illegal_instruction mov al,[extended_code] mov [base_code],al call get_word_value push eax inc esi lods byte [esi] cmp al,'(' jne invalid_operand mov al,[value_type] push eax [symbol_identifier] cmp byte [esi],'.' je invalid_value mov al,[operand_size] cmp al,4 je jmp_far_16bit cmp al,6 je jmp_far_32bit or al,al jnz invalid_operand_size cmp [code_type],16 jne jmp_far_32bit jmp_far_16bit: call get_word_value mov ebx,eax call operand_16bit call store_instruction_code mov ax,bx call mark_relocation stos word [edi] jmp_far_segment: pop [symbol_identifier] eax mov [value_type],al pop eax call mark_relocation stos word [edi] jmp instruction_assembled jmp_far_32bit: call get_dword_value mov ebx,eax call operand_32bit call store_instruction_code mov eax,ebx call mark_relocation stos dword [edi] jmp jmp_far_segment conditional_jump: mov [base_code],al lods byte [esi] call get_jump_operator cmp [jump_type],3 je invalid_operand call get_size_operator cmp al,'(' jne invalid_operand cmp byte [esi],'.' je invalid_value mov al,[operand_size] cmp al,2 je conditional_jump_16bit cmp al,4 je conditional_jump_32bit cmp al,8 je conditional_jump_64bit or al,al jnz invalid_operand_size cmp [code_type],16 je conditional_jump_16bit cmp [code_type],64 je conditional_jump_64bit conditional_jump_32bit: cmp [code_type],64 je invalid_operand_size call get_address_dword_value cmp [code_type],16 jne conditional_jump_32bit_prefix_ok mov byte [edi],66h inc edi conditional_jump_32bit_prefix_ok: call calculate_jump_offset cdq call check_for_short_jump jc conditional_jump_short conditional_jump_32bit_store: mov edx,eax sub edx,4 mov ah,[base_code] add ah,10h mov al,0Fh stos word [edi] mov eax,edx call mark_relocation stos dword [edi] jmp instruction_assembled conditional_jump_64bit: cmp [code_type],64 jne invalid_operand_size call get_address_qword_value call calculate_jump_offset mov ecx,edx cdq cmp edx,ecx jne value_out_of_range call check_for_short_jump jnc conditional_jump_32bit_store conditional_jump_short: mov ah,al mov al,[base_code] stos word [edi] jmp instruction_assembled conditional_jump_16bit: call get_address_word_value cmp [code_type],16 je conditional_jump_16bit_prefix_ok mov byte [edi],66h inc edi conditional_jump_16bit_prefix_ok: call calculate_jump_offset cwde cdq call check_for_short_jump jc conditional_jump_short cmp [value_type],0 jne invalid_use_of_symbol mov edx,eax sub edx,2 mov ah,[base_code] add ah,10h mov al,0Fh stos word [edi] mov eax,edx stos word [edi] jmp instruction_assembled loop_instruction_16bit: cmp [code_type],64 je illegal_instruction mov dl,al call address_16bit_prefix mov al,dl jmp loop_instruction loop_instruction_32bit: mov dl,al call address_32bit_prefix mov al,dl jmp loop_instruction loop_instruction_64bit: cmp [code_type],64 jne illegal_instruction loop_instruction: mov [base_code],al lods byte [esi] call get_jump_operator cmp [jump_type],1 ja invalid_operand call get_size_operator cmp al,'(' jne invalid_operand cmp byte [esi],'.' je invalid_value mov al,[operand_size] cmp al,2 je loop_jump_16bit cmp al,4 je loop_jump_32bit cmp al,8 je loop_jump_64bit or al,al jnz invalid_operand_size cmp [code_type],16 je loop_jump_16bit cmp [code_type],64 je loop_jump_64bit loop_jump_32bit: cmp [code_type],64 je invalid_operand_size call get_address_dword_value cmp [code_type],16 jne loop_jump_32bit_prefix_ok mov byte [edi],66h inc edi loop_jump_32bit_prefix_ok: call calculate_jump_offset cdq make_loop_jump: call check_for_short_jump jc conditional_jump_short jmp jump_out_of_range loop_jump_64bit: cmp [code_type],64 jne invalid_operand_size call get_address_qword_value call calculate_jump_offset mov ecx,edx cdq cmp edx,ecx jne value_out_of_range jmp make_loop_jump loop_jump_16bit: call get_address_word_value cmp [code_type],16 je loop_jump_16bit_prefix_ok mov byte [edi],66h inc edi loop_jump_16bit_prefix_ok: call calculate_jump_offset cwde cdq jmp make_loop_jump movs_instruction: lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address or eax,eax jnz invalid_address or bl,ch jnz invalid_address cmp [segment_register],1 ja invalid_address push ebx lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address pop edx or eax,eax jnz invalid_address or bl,ch jnz invalid_address mov al,dh mov ah,bh shr al,4 shr ah,4 cmp al,ah jne address_sizes_do_not_agree and bh,111b and dh,111b cmp bh,6 jne invalid_address cmp dh,7 jne invalid_address cmp al,2 je movs_address_16bit cmp al,4 je movs_address_32bit cmp [code_type],64 jne invalid_address_size jmp movs_store movs_address_32bit: call address_32bit_prefix jmp movs_store movs_address_16bit: cmp [code_type],64 je invalid_address_size call address_16bit_prefix movs_store: cmp [segment_register],4 je movs_segment_ok call store_segment_prefix movs_segment_ok: mov al,0A4h mov bl,[operand_size] cmp bl,1 je simple_instruction inc al cmp bl,2 je simple_instruction_16bit cmp bl,4 je simple_instruction_32bit cmp bl,8 je simple_instruction_64bit or bl,bl jz operand_size_not_specified jmp invalid_operand_size lods_instruction: lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address or eax,eax jnz invalid_address or bl,ch jnz invalid_address cmp bh,26h je lods_address_16bit cmp bh,46h je lods_address_32bit cmp bh,86h jne invalid_address cmp [code_type],64 jne invalid_address_size jmp lods_store lods_address_32bit: call address_32bit_prefix jmp lods_store lods_address_16bit: cmp [code_type],64 je invalid_address_size call address_16bit_prefix lods_store: cmp [segment_register],4 je lods_segment_ok call store_segment_prefix lods_segment_ok: mov al,0ACh mov bl,[operand_size] cmp bl,1 je simple_instruction inc al cmp bl,2 je simple_instruction_16bit cmp bl,4 je simple_instruction_32bit cmp bl,8 je simple_instruction_64bit or bl,bl jz operand_size_not_specified jmp invalid_operand_size stos_instruction: mov [base_code],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address or eax,eax jnz invalid_address or bl,ch jnz invalid_address cmp bh,27h je stos_address_16bit cmp bh,47h je stos_address_32bit cmp bh,87h jne invalid_address cmp [code_type],64 jne invalid_address_size jmp stos_store stos_address_32bit: call address_32bit_prefix jmp stos_store stos_address_16bit: cmp [code_type],64 je invalid_address_size call address_16bit_prefix stos_store: cmp [segment_register],1 ja invalid_address mov al,[base_code] mov bl,[operand_size] cmp bl,1 je simple_instruction inc al cmp bl,2 je simple_instruction_16bit cmp bl,4 je simple_instruction_32bit cmp bl,8 je simple_instruction_64bit or bl,bl jz operand_size_not_specified jmp invalid_operand_size cmps_instruction: lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address or eax,eax jnz invalid_address or bl,ch jnz invalid_address mov al,[segment_register] push eax ebx lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address or eax,eax jnz invalid_address or bl,ch jnz invalid_address pop edx eax cmp [segment_register],1 ja invalid_address mov [segment_register],al mov al,dh mov ah,bh shr al,4 shr ah,4 cmp al,ah jne address_sizes_do_not_agree and bh,111b and dh,111b cmp bh,7 jne invalid_address cmp dh,6 jne invalid_address cmp al,2 je cmps_address_16bit cmp al,4 je cmps_address_32bit cmp [code_type],64 jne invalid_address_size jmp cmps_store cmps_address_32bit: call address_32bit_prefix jmp cmps_store cmps_address_16bit: cmp [code_type],64 je invalid_address_size call address_16bit_prefix cmps_store: cmp [segment_register],4 je cmps_segment_ok call store_segment_prefix cmps_segment_ok: mov al,0A6h mov bl,[operand_size] cmp bl,1 je simple_instruction inc al cmp bl,2 je simple_instruction_16bit cmp bl,4 je simple_instruction_32bit cmp bl,8 je simple_instruction_64bit or bl,bl jz operand_size_not_specified jmp invalid_operand_size ins_instruction: lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address or eax,eax jnz invalid_address or bl,ch jnz invalid_address cmp bh,27h je ins_address_16bit cmp bh,47h je ins_address_32bit cmp bh,87h jne invalid_address cmp [code_type],64 jne invalid_address_size jmp ins_store ins_address_32bit: call address_32bit_prefix jmp ins_store ins_address_16bit: cmp [code_type],64 je invalid_address_size call address_16bit_prefix ins_store: cmp [segment_register],1 ja invalid_address lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] cmp al,10h jne invalid_operand lods byte [esi] cmp al,22h jne invalid_operand mov al,6Ch mov bl,[operand_size] cmp bl,1 je simple_instruction inc al cmp bl,2 je simple_instruction_16bit cmp bl,4 je simple_instruction_32bit or bl,bl jz operand_size_not_specified jmp invalid_operand_size outs_instruction: lods byte [esi] cmp al,10h jne invalid_operand lods byte [esi] cmp al,22h jne invalid_operand lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address or eax,eax jnz invalid_address or bl,ch jnz invalid_address cmp bh,26h je outs_address_16bit cmp bh,46h je outs_address_32bit cmp bh,86h jne invalid_address cmp [code_type],64 jne invalid_address_size jmp outs_store outs_address_32bit: call address_32bit_prefix jmp outs_store outs_address_16bit: cmp [code_type],64 je invalid_address_size call address_16bit_prefix outs_store: cmp [segment_register],4 je outs_segment_ok call store_segment_prefix outs_segment_ok: mov al,6Eh mov bl,[operand_size] cmp bl,1 je simple_instruction inc al cmp bl,2 je simple_instruction_16bit cmp bl,4 je simple_instruction_32bit or bl,bl jz operand_size_not_specified jmp invalid_operand_size xlat_instruction: lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address or eax,eax jnz invalid_address or bl,ch jnz invalid_address cmp bh,23h je xlat_address_16bit cmp bh,43h je xlat_address_32bit cmp bh,83h jne invalid_address cmp [code_type],64 jne invalid_address_size jmp xlat_store xlat_address_32bit: call address_32bit_prefix jmp xlat_store xlat_address_16bit: cmp [code_type],64 je invalid_address_size call address_16bit_prefix xlat_store: call store_segment_prefix_if_necessary mov al,0D7h cmp [operand_size],1 jbe simple_instruction jmp invalid_operand_size pm_word_instruction: mov ah,al shr ah,4 and al,111b mov [base_code],0Fh mov [extended_code],ah mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,10h je pm_reg pm_mem: cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] cmp al,2 je pm_mem_store or al,al jnz invalid_operand_size pm_mem_store: call store_instruction jmp instruction_assembled pm_reg: lods byte [esi] call convert_register mov bl,al cmp ah,2 jne invalid_operand_size call store_nomem_instruction jmp instruction_assembled pm_store_word_instruction: mov ah,al shr ah,4 and al,111b mov [base_code],0Fh mov [extended_code],ah mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,10h jne pm_mem lods byte [esi] call convert_register mov bl,al mov al,ah call operand_autodetect call store_nomem_instruction jmp instruction_assembled lgdt_instruction: mov [base_code],0Fh mov [extended_code],1 mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] cmp al,6 je lgdt_mem_48bit cmp al,10 je lgdt_mem_80bit or al,al jnz invalid_operand_size jmp lgdt_mem_store lgdt_mem_80bit: cmp [code_type],64 jne illegal_instruction jmp lgdt_mem_store lgdt_mem_48bit: cmp [code_type],64 je illegal_instruction cmp [postbyte_register],2 jb lgdt_mem_store call operand_32bit lgdt_mem_store: call store_instruction jmp instruction_assembled lar_instruction: mov [extended_code],al mov [base_code],0Fh 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 al,al xchg al,[operand_size] call operand_autodetect lods byte [esi] call get_size_operator cmp al,10h je lar_reg_reg cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] or al,al jz lar_reg_mem cmp al,2 jne invalid_operand_size lar_reg_mem: call store_instruction jmp instruction_assembled lar_reg_reg: lods byte [esi] call convert_register cmp ah,2 jne invalid_operand_size mov bl,al call store_nomem_instruction jmp instruction_assembled invlpg_instruction: mov [base_code],0Fh mov [extended_code],1 mov [postbyte_register],7 lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address call store_instruction jmp instruction_assembled swapgs_instruction: mov [base_code],0Fh mov [extended_code],1 mov [postbyte_register],7 mov bl,al call store_nomem_instruction jmp instruction_assembled basic_486_instruction: mov [base_code],0Fh mov [extended_code],al lods byte [esi] call get_size_operator cmp al,10h je basic_486_reg cmp al,'[' jne invalid_operand call get_address push edx ebx ecx 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_register mov [postbyte_register],al pop ecx ebx edx mov al,ah cmp al,1 je basic_486_mem_reg_8bit call operand_autodetect inc [extended_code] basic_486_mem_reg_8bit: call store_instruction jmp instruction_assembled basic_486_reg: lods byte [esi] call convert_register mov [postbyte_register],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_register mov bl,[postbyte_register] mov [postbyte_register],al mov al,ah cmp al,1 je basic_486_reg_reg_8bit call operand_autodetect inc [extended_code] basic_486_reg_reg_8bit: call store_nomem_instruction jmp instruction_assembled bswap_instruction: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register test al,1000b jz bswap_reg_code_ok or [rex_prefix],41h and al,111b bswap_reg_code_ok: add al,0C8h mov [extended_code],al mov [base_code],0Fh cmp ah,8 je bswap_reg64 cmp ah,4 jne invalid_operand_size call operand_32bit call store_instruction_code jmp instruction_assembled bswap_reg64: call operand_64bit call store_instruction_code jmp instruction_assembled cmpxchgx_instruction: mov [base_code],0Fh mov [extended_code],0C7h mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov ah,1 xchg [postbyte_register],ah mov al,[operand_size] or al,al jz cmpxchgx_size_ok cmp al,ah jne invalid_operand_size cmpxchgx_size_ok: cmp ah,16 jne cmpxchgx_store call operand_64bit cmpxchgx_store: call store_instruction jmp instruction_assembled nop_instruction: mov ah,[esi] cmp ah,10h je extended_nop cmp ah,11h je extended_nop cmp ah,'[' je extended_nop stos byte [edi] jmp instruction_assembled extended_nop: mov [base_code],0Fh mov [extended_code],1Fh mov [postbyte_register],0 lods byte [esi] call get_size_operator cmp al,10h je extended_nop_reg cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] or al,al jz extended_nop_nosize call operand_autodetect extended_nop_store: call store_instruction jmp instruction_assembled extended_nop_nosize: cmp [error_line],0 jne extended_nop_store mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified jmp extended_nop_store extended_nop_reg: lods byte [esi] call convert_register mov bl,al mov al,ah call operand_autodetect call store_nomem_instruction jmp instruction_assembled basic_fpu_instruction: mov [postbyte_register],al mov [base_code],0D8h lods byte [esi] call get_size_operator cmp al,10h je basic_fpu_streg cmp al,'[' je basic_fpu_mem dec esi mov ah,[postbyte_register] cmp ah,2 jb invalid_operand cmp ah,3 ja invalid_operand mov bl,1 call store_nomem_instruction jmp instruction_assembled basic_fpu_mem: call get_address mov al,[operand_size] cmp al,4 je basic_fpu_mem_32bit cmp al,8 je basic_fpu_mem_64bit or al,al jnz invalid_operand_size cmp [error_line],0 jne basic_fpu_mem_32bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified basic_fpu_mem_32bit: call store_instruction jmp instruction_assembled basic_fpu_mem_64bit: mov [base_code],0DCh call store_instruction jmp instruction_assembled basic_fpu_streg: lods byte [esi] call convert_fpu_register mov bl,al mov ah,[postbyte_register] cmp ah,2 je basic_fpu_single_streg cmp ah,3 je basic_fpu_single_streg or al,al jz basic_fpu_st0 test ah,110b jz basic_fpu_streg_st0 xor [postbyte_register],1 basic_fpu_streg_st0: 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_fpu_register or al,al jnz invalid_operand mov [base_code],0DCh call store_nomem_instruction jmp instruction_assembled basic_fpu_st0: 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_fpu_register mov bl,al basic_fpu_single_streg: mov [base_code],0D8h call store_nomem_instruction jmp instruction_assembled simple_fpu_instruction: mov ah,al or ah,11000000b mov al,0D9h stos word [edi] jmp instruction_assembled fi_instruction: mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] cmp al,2 je fi_mem_16bit cmp al,4 je fi_mem_32bit or al,al jnz invalid_operand_size cmp [error_line],0 jne fi_mem_32bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified fi_mem_32bit: mov [base_code],0DAh call store_instruction jmp instruction_assembled fi_mem_16bit: mov [base_code],0DEh call store_instruction jmp instruction_assembled fld_instruction: mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,10h je fld_streg cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] cmp al,4 je fld_mem_32bit cmp al,8 je fld_mem_64bit cmp al,10 je fld_mem_80bit or al,al jnz invalid_operand_size cmp [error_line],0 jne fld_mem_32bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified fld_mem_32bit: mov [base_code],0D9h call store_instruction jmp instruction_assembled fld_mem_64bit: mov [base_code],0DDh call store_instruction jmp instruction_assembled fld_mem_80bit: mov al,[postbyte_register] cmp al,0 je fld_mem_80bit_store dec [postbyte_register] cmp al,3 je fld_mem_80bit_store jmp invalid_operand_size fld_mem_80bit_store: add [postbyte_register],5 mov [base_code],0DBh call store_instruction jmp instruction_assembled fld_streg: lods byte [esi] call convert_fpu_register mov bl,al cmp [postbyte_register],2 jae fst_streg mov [base_code],0D9h call store_nomem_instruction jmp instruction_assembled fst_streg: mov [base_code],0DDh call store_nomem_instruction jmp instruction_assembled fild_instruction: mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] cmp al,2 je fild_mem_16bit cmp al,4 je fild_mem_32bit cmp al,8 je fild_mem_64bit or al,al jnz invalid_operand_size cmp [error_line],0 jne fild_mem_32bit mov eax,[current_line] mov [error_line],eax mov [error],operand_size_not_specified fild_mem_32bit: mov [base_code],0DBh call store_instruction jmp instruction_assembled fild_mem_16bit: mov [base_code],0DFh call store_instruction jmp instruction_assembled fild_mem_64bit: mov al,[postbyte_register] cmp al,1 je fisttp_64bit_store jb fild_mem_64bit_store dec [postbyte_register] cmp al,3 je fild_mem_64bit_store jmp invalid_operand_size fild_mem_64bit_store: add [postbyte_register],5 mov [base_code],0DFh call store_instruction jmp instruction_assembled fisttp_64bit_store: mov [base_code],0DDh call store_instruction jmp instruction_assembled fbld_instruction: mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] or al,al jz fbld_mem_80bit cmp al,10 je fbld_mem_80bit jmp invalid_operand_size fbld_mem_80bit: mov [base_code],0DFh call store_instruction jmp instruction_assembled faddp_instruction: mov [postbyte_register],al mov [base_code],0DEh mov edx,esi lods byte [esi] call get_size_operator cmp al,10h je faddp_streg mov esi,edx mov bl,1 call store_nomem_instruction jmp instruction_assembled faddp_streg: lods byte [esi] call convert_fpu_register 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_fpu_register or al,al jnz invalid_operand call store_nomem_instruction jmp instruction_assembled fcompp_instruction: mov ax,0D9DEh stos word [edi] jmp instruction_assembled fucompp_instruction: mov ax,0E9DAh stos word [edi] jmp instruction_assembled fxch_instruction: mov dx,01D9h jmp fpu_single_operand ffreep_instruction: mov dx,00DFh jmp fpu_single_operand ffree_instruction: mov dl,0DDh mov dh,al fpu_single_operand: mov ebx,esi lods byte [esi] call get_size_operator cmp al,10h je fpu_streg or dh,dh jz invalid_operand mov esi,ebx shl dh,3 or dh,11000001b mov ax,dx stos word [edi] jmp instruction_assembled fpu_streg: lods byte [esi] call convert_fpu_register shl dh,3 or dh,al or dh,11000000b mov ax,dx stos word [edi] jmp instruction_assembled fstenv_instruction: mov byte [edi],9Bh inc edi fldenv_instruction: mov [base_code],0D9h jmp fpu_mem fsave_instruction: mov byte [edi],9Bh inc edi fnsave_instruction: mov [base_code],0DDh fpu_mem: mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address cmp [operand_size],0 jne invalid_operand_size call store_instruction jmp instruction_assembled fstcw_instruction: mov byte [edi],9Bh inc edi fldcw_instruction: mov [postbyte_register],al mov [base_code],0D9h lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] or al,al jz fldcw_mem_16bit cmp al,2 je fldcw_mem_16bit jmp invalid_operand_size fldcw_mem_16bit: call store_instruction jmp instruction_assembled fstsw_instruction: mov al,9Bh stos byte [edi] fnstsw_instruction: mov [base_code],0DDh mov [postbyte_register],7 lods byte [esi] call get_size_operator cmp al,10h je fstsw_reg cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] or al,al jz fstsw_mem_16bit cmp al,2 je fstsw_mem_16bit jmp invalid_operand_size fstsw_mem_16bit: call store_instruction jmp instruction_assembled fstsw_reg: lods byte [esi] call convert_register cmp ax,0200h jne invalid_operand mov ax,0E0DFh stos word [edi] jmp instruction_assembled finit_instruction: mov byte [edi],9Bh inc edi fninit_instruction: mov ah,al mov al,0DBh stos word [edi] jmp instruction_assembled fcmov_instruction: mov dh,0DAh jmp fcomi_streg fcomi_instruction: mov dh,0DBh jmp fcomi_streg fcomip_instruction: mov dh,0DFh fcomi_streg: mov dl,al lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_fpu_register mov ah,al cmp byte [esi],',' je fcomi_st0_streg add ah,dl mov al,dh stos word [edi] jmp instruction_assembled fcomi_st0_streg: or ah,ah jnz invalid_operand inc esi lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_fpu_register mov ah,al add ah,dl mov al,dh stos word [edi] jmp instruction_assembled basic_mmx_instruction: mov [base_code],0Fh mov [extended_code],al mmx_instruction: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register call make_mmx_prefix mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,10h je mmx_mmreg_mmreg cmp al,'[' jne invalid_operand mmx_mmreg_mem: call get_address call store_instruction jmp instruction_assembled mmx_mmreg_mmreg: lods byte [esi] call convert_mmx_register mov bl,al call store_nomem_instruction jmp instruction_assembled mmx_ps_instruction: 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_mmx_register call make_mmx_prefix mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand mov [operand_size],0 lods byte [esi] call get_size_operator cmp al,10h je mmx_mmreg_mmreg cmp al,'(' je mmx_ps_mmreg_imm8 cmp al,'[' je mmx_mmreg_mem jmp invalid_operand mmx_ps_mmreg_imm8: call get_byte_value mov byte [value],al test [operand_size],not 1 jnz invalid_value 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] call store_nomem_instruction mov al,byte [value] stos byte [edi] jmp instruction_assembled pextrw_instruction: 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 jnz 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 jne invalid_operand lods byte [esi] call convert_mmx_register mov bl,al call make_mmx_prefix cmp [extended_code],0C5h je mmx_nomem_imm8 call store_nomem_instruction jmp instruction_assembled mmx_imm8: push ebx ecx edx mov [operand_size],0 lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator test ah,not 1 jnz invalid_operand_size cmp al,'(' jne invalid_operand call get_byte_value mov byte [value],al pop edx ecx ebx call store_instruction_with_imm8 jmp instruction_assembled mmx_nomem_imm8: call store_nomem_instruction mov [operand_size],0 lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator test ah,not 1 jnz invalid_operand_size cmp al,'(' jne invalid_operand call get_byte_value stosb jmp instruction_assembled pinsrw_instruction: mov [extended_code],al mov [base_code],0Fh lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register call make_mmx_prefix 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 pinsrw_mmreg_reg cmp al,'[' jne invalid_operand call get_address cmp [operand_size],0 je mmx_imm8 cmp [operand_size],2 jne invalid_operand_size jmp mmx_imm8 pinsrw_mmreg_reg: lods byte [esi] call convert_register cmp ah,4 jne invalid_operand_size mov bl,al jmp mmx_nomem_imm8 pshufw_instruction: mov [mmx_size],8 mov [operand_prefix],al jmp pshuf_instruction pshufd_instruction: mov [mmx_size],16 mov [operand_prefix],al pshuf_instruction: mov [base_code],0Fh mov [extended_code],70h lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,[mmx_size] jne invalid_operand_size mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,10h je pshuf_mmreg_mmreg cmp al,'[' jne invalid_operand call get_address jmp mmx_imm8 pshuf_mmreg_mmreg: lods byte [esi] call convert_mmx_register mov bl,al jmp mmx_nomem_imm8 movd_instruction: mov [base_code],0Fh mov [extended_code],7Eh lods byte [esi] call get_size_operator cmp al,10h je movd_reg cmp al,'[' jne invalid_operand call get_address test [operand_size],not 4 jnz invalid_operand_size 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_mmx_register call make_mmx_prefix mov [postbyte_register],al call store_instruction jmp instruction_assembled movd_reg: lods byte [esi] cmp al,0B0h jae movd_mmreg call convert_register cmp ah,4 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_mmx_register mov [postbyte_register],al call make_mmx_prefix call store_nomem_instruction jmp instruction_assembled movd_mmreg: mov [extended_code],6Eh call convert_mmx_register call make_mmx_prefix 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 movd_mmreg_reg cmp al,'[' jne invalid_operand call get_address test [operand_size],not 4 jnz invalid_operand_size call store_instruction jmp instruction_assembled movd_mmreg_reg: lods byte [esi] call convert_register cmp ah,4 jne invalid_operand_size mov bl,al call store_nomem_instruction jmp instruction_assembled make_mmx_prefix: cmp [operand_size],16 jne no_mmx_prefix mov [operand_prefix],66h no_mmx_prefix: ret movq_instruction: mov [base_code],0Fh lods byte [esi] call get_size_operator cmp al,10h je movq_reg cmp al,'[' jne invalid_operand call get_address test [operand_size],not 8 jnz invalid_operand_size mov [operand_size],0 lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register mov [postbyte_register],al cmp ah,16 je movq_mem_xmmreg mov [extended_code],7Fh call store_instruction jmp instruction_assembled movq_mem_xmmreg: mov [extended_code],0D6h mov [operand_prefix],66h call store_instruction jmp instruction_assembled movq_reg: lods byte [esi] cmp al,0B0h jae movq_mmreg call convert_register cmp ah,8 jne invalid_operand_size 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_mmx_register mov [postbyte_register],al call make_mmx_prefix mov [extended_code],7Eh call operand_64bit call store_nomem_instruction jmp instruction_assembled movq_mmreg: call convert_mmx_register mov [postbyte_register],al mov [extended_code],6Fh mov [mmx_size],ah cmp ah,16 jne movq_mmreg_ mov [extended_code],7Eh mov [operand_prefix],0F3h movq_mmreg_: lods byte [esi] cmp al,',' jne invalid_operand mov [operand_size],0 lods byte [esi] call get_size_operator cmp al,10h je movq_mmreg_reg call get_address test [operand_size],not 8 jnz invalid_operand_size call store_instruction jmp instruction_assembled movq_mmreg_reg: lods byte [esi] cmp al,0B0h jae movq_mmreg_mmreg mov [operand_size],0 call convert_register cmp ah,8 jne invalid_operand_size mov [extended_code],6Eh mov [operand_prefix],0 mov bl,al cmp [mmx_size],16 jne movq_mmreg_reg_store mov [operand_prefix],66h movq_mmreg_reg_store: call operand_64bit call store_nomem_instruction jmp instruction_assembled movq_mmreg_mmreg: call convert_mmx_register mov bl,al call store_nomem_instruction jmp instruction_assembled movdq_instruction: mov [operand_prefix],al mov [base_code],0Fh mov [extended_code],6Fh lods byte [esi] call get_size_operator cmp al,10h je movdq_mmreg cmp al,'[' jne invalid_operand call get_address 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_mmx_register cmp ah,16 jne invalid_operand_size mov [postbyte_register],al mov [extended_code],7Fh call store_instruction jmp instruction_assembled movdq_mmreg: lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_operand_size mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,10h je movdq_mmreg_mmreg cmp al,'[' jne invalid_operand call get_address call store_instruction jmp instruction_assembled movdq_mmreg_mmreg: lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_operand_size mov bl,al call store_nomem_instruction jmp instruction_assembled lddqu_instruction: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_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 mov [postbyte_register],al mov [operand_prefix],0F2h mov [base_code],0Fh mov [extended_code],0F0h call store_instruction jmp instruction_assembled movq2dq_instruction: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_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 jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,8 jne invalid_operand_size mov bl,al mov [operand_prefix],0F3h mov [base_code],0Fh mov [extended_code],0D6h call store_nomem_instruction jmp instruction_assembled movdq2q_instruction: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,8 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 jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_operand_size mov bl,al mov [operand_prefix],0F2h mov [base_code],0Fh mov [extended_code],0D6h call store_nomem_instruction jmp instruction_assembled sse_ps_instruction: mov [mmx_size],16 jmp sse_instruction sse_pd_instruction: mov [mmx_size],16 mov [operand_prefix],66h jmp sse_instruction sse_ss_instruction: mov [mmx_size],4 mov [operand_prefix],0F3h jmp sse_instruction sse_sd_instruction: mov [mmx_size],8 mov [operand_prefix],0F2h jmp sse_instruction comiss_instruction: mov [mmx_size],4 jmp sse_instruction comisd_instruction: mov [mmx_size],8 mov [operand_prefix],66h jmp sse_instruction cvtps2pd_instruction: mov [mmx_size],8 jmp sse_instruction cvtpd2dq_instruction: mov [mmx_size],16 mov [operand_prefix],0F2h jmp sse_instruction cvtdq2pd_instruction: mov [mmx_size],16 mov [operand_prefix],0F3h sse_instruction: mov [base_code],0Fh mov [extended_code],al lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand sse_xmmreg: lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_operand_size sse_reg: 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 sse_xmmreg_xmmreg sse_reg_mem: cmp al,'[' jne invalid_operand call get_address cmp [operand_size],0 je sse_mem_size_ok mov al,[mmx_size] cmp [operand_size],al jne invalid_operand_size sse_mem_size_ok: cmp [extended_code],0C6h je mmx_imm8 call store_instruction jmp instruction_assembled sse_xmmreg_xmmreg: cmp [operand_prefix],66h jne sse_xmmreg_xmmreg_ok cmp [extended_code],12h je invalid_operand cmp [extended_code],16h je invalid_operand sse_xmmreg_xmmreg_ok: lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_operand_size mov bl,al cmp [extended_code],0C6h je mmx_nomem_imm8 call store_nomem_instruction jmp instruction_assembled ps_dq_instruction: mov [postbyte_register],al mov [operand_prefix],66h mov [base_code],0Fh mov [extended_code],73h lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_operand_size mov bl,al jmp mmx_nomem_imm8 movpd_instruction: mov [operand_prefix],66h movps_instruction: mov [base_code],0Fh mov [extended_code],al mov [mmx_size],16 jmp sse_mov_instruction movss_instruction: mov [mmx_size],4 mov [operand_prefix],0F3h jmp sse_movs movsd_instruction: mov al,0A5h mov ah,[esi] or ah,ah jz simple_instruction_32bit cmp ah,0Fh je simple_instruction_32bit mov [mmx_size],8 mov [operand_prefix],0F2h sse_movs: mov [base_code],0Fh mov [extended_code],10h jmp sse_mov_instruction sse_mov_instruction: lods byte [esi] call get_size_operator cmp al,10h je sse_xmmreg sse_mem: cmp al,'[' jne invalid_operand inc [extended_code] call get_address cmp [operand_size],0 je sse_mem_xmmreg mov al,[mmx_size] cmp [operand_size],al jne invalid_operand_size mov [operand_size],0 sse_mem_xmmreg: 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_mmx_register cmp ah,16 jne invalid_operand_size mov [postbyte_register],al call store_instruction jmp instruction_assembled movlpd_instruction: mov [operand_prefix],66h movlps_instruction: mov [base_code],0Fh mov [extended_code],al mov [mmx_size],8 lods byte [esi] call get_size_operator cmp al,10h jne sse_mem lods byte [esi] call convert_mmx_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 jmp sse_reg_mem movhlps_instruction: mov [base_code],0Fh mov [extended_code],al mov [mmx_size],0 lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_operand_size mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,10h je sse_xmmreg_xmmreg_ok jmp invalid_operand maskmovq_instruction: mov cl,8 jmp maskmov_instruction maskmovdqu_instruction: mov cl,16 mov [operand_prefix],66h maskmov_instruction: mov [base_code],0Fh mov [extended_code],0F7h lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,cl jne invalid_operand_size mov [postbyte_register],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_mmx_register mov bl,al call store_nomem_instruction jmp instruction_assembled movmskpd_instruction: mov [operand_prefix],66h movmskps_instruction: mov [base_code],0Fh mov [extended_code],50h lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register cmp ah,4 jne invalid_operand_size mov [operand_size],0 mov [postbyte_register],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_mmx_register cmp ah,16 jne invalid_operand_size mov bl,al call store_nomem_instruction jmp instruction_assembled cmppd_instruction: mov [operand_prefix],66h cmpps_instruction: mov [base_code],0Fh mov [extended_code],0C2h mov [mmx_size],16 mov byte [value],-1 jmp sse_cmp_instruction cmp_pd_instruction: mov [operand_prefix],66h cmp_ps_instruction: mov [base_code],0Fh mov [extended_code],0C2h mov [mmx_size],16 mov byte [value],al jmp sse_cmp_instruction cmpss_instruction: mov [mmx_size],4 mov [operand_prefix],0F3h jmp cmpsx_instruction cmpsd_instruction: mov al,0A7h mov ah,[esi] or ah,ah jz simple_instruction_32bit cmp ah,0Fh je simple_instruction_32bit mov [mmx_size],8 mov [operand_prefix],0F2h cmpsx_instruction: mov [base_code],0Fh mov [extended_code],0C2h mov byte [value],-1 jmp sse_cmp_instruction cmp_ss_instruction: mov [mmx_size],4 mov [operand_prefix],0F3h jmp cmp_sx_instruction cmp_sd_instruction: mov [mmx_size],8 mov [operand_prefix],0F2h cmp_sx_instruction: mov [base_code],0Fh mov [extended_code],0C2h mov byte [value],al sse_cmp_instruction: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_operand_size mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand mov [operand_size],0 lods byte [esi] call get_size_operator cmp al,10h je sse_cmp_xmmreg_xmmreg cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] or al,al jz sse_cmp_size_ok cmp al,[mmx_size] jne invalid_operand_size sse_cmp_size_ok: push ebx ecx edx call get_nextbyte pop edx ecx ebx call store_instruction_with_imm8 jmp instruction_assembled sse_cmp_xmmreg_xmmreg: lods byte [esi] call convert_mmx_register cmp ah,16 jne invalid_operand_size mov bl,al call store_nomem_instruction call get_nextbyte mov al,byte [value] stos byte [edi] jmp instruction_assembled get_nextbyte: cmp byte [value],-1 jne nextbyte_ok mov [operand_size],0 lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator test [operand_size],not 1 jnz invalid_value cmp al,'(' jne invalid_operand call get_byte_value cmp al,7 ja invalid_value mov byte [value],al nextbyte_ok: ret cvtpi2pd_instruction: mov [operand_prefix],66h cvtpi2ps_instruction: 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_mmx_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 cvtpi_xmmreg_xmmreg cmp al,'[' jne invalid_operand call get_address cmp [operand_size],0 je cvtpi_size_ok cmp [operand_size],8 jne invalid_operand_size cvtpi_size_ok: call store_instruction jmp instruction_assembled cvtpi_xmmreg_xmmreg: lods byte [esi] call convert_mmx_register cmp ah,8 jne invalid_operand_size mov bl,al call store_nomem_instruction jmp instruction_assembled cvtsi2ss_instruction: mov [operand_prefix],0F3h jmp cvtsi_instruction cvtsi2sd_instruction: mov [operand_prefix],0F2h cvtsi_instruction: 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_mmx_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 cvtsi_xmmreg_reg cmp al,'[' jne invalid_operand call get_address cmp [operand_size],0 je cvtsi_size_ok cmp [operand_size],4 jne invalid_operand_size cvtsi_size_ok: call store_instruction jmp instruction_assembled cvtsi_xmmreg_reg: lods byte [esi] call convert_register cmp ah,4 je cvtsi_xmmreg_reg_store cmp ah,8 jne invalid_operand_size call operand_64bit cvtsi_xmmreg_reg_store: mov bl,al call store_nomem_instruction jmp instruction_assembled cvtps2pi_instruction: mov [mmx_size],8 jmp cvtpd_instruction cvtpd2pi_instruction: mov [operand_prefix],66h mov [mmx_size],16 cvtpd_instruction: 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_mmx_register cmp ah,8 jne invalid_operand_size mov [operand_size],0 jmp sse_reg cvtss2si_instruction: mov [operand_prefix],0F3h mov [mmx_size],4 jmp cvt2si_instruction cvtsd2si_instruction: mov [operand_prefix],0F2h mov [mmx_size],8 cvt2si_instruction: mov [extended_code],al mov [base_code],0Fh lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register mov [operand_size],0 cmp ah,4 je sse_reg cmp ah,8 jne invalid_operand_size call operand_64bit jmp sse_reg ssse3_instruction: mov [base_code],0Fh mov [extended_code],38h mov [supplemental_code],al jmp mmx_instruction palignr_instruction: mov [base_code],0Fh mov [extended_code],3Ah mov [supplemental_code],0Fh lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register call make_mmx_prefix mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,10h je palignr_mmreg_mmreg cmp al,'[' jne invalid_operand call get_address jmp mmx_imm8 palignr_mmreg_mmreg: lods byte [esi] call convert_mmx_register mov bl,al jmp mmx_nomem_imm8 amd3dnow_instruction: mov [base_code],0Fh mov [extended_code],0Fh mov byte [value],al lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_mmx_register cmp ah,8 jne invalid_operand_size mov [postbyte_register],al lods byte [esi] cmp al,',' jne invalid_operand lods byte [esi] call get_size_operator cmp al,10h je amd3dnow_mmreg_mmreg cmp al,'[' jne invalid_operand call get_address call store_instruction_with_imm8 jmp instruction_assembled amd3dnow_mmreg_mmreg: lods byte [esi] call convert_mmx_register cmp ah,8 jne invalid_operand_size mov bl,al call store_nomem_instruction mov al,byte [value] stos byte [edi] jmp instruction_assembled fxsave_instruction: mov [extended_code],0AEh mov [base_code],0Fh mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov ah,[operand_size] or ah,ah jz fxsave_size_ok mov al,[postbyte_register] cmp al,111b je clflush_size_check cmp al,10b jb invalid_operand_size cmp al,11b ja invalid_operand_size cmp ah,4 jne invalid_operand_size jmp fxsave_size_ok clflush_size_check: cmp ah,1 jne invalid_operand_size fxsave_size_ok: call store_instruction jmp instruction_assembled prefetch_instruction: mov [extended_code],18h prefetch_mem_8bit: mov [base_code],0Fh mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand or ah,ah jz prefetch_size_ok cmp ah,1 jne invalid_operand_size prefetch_size_ok: call get_address call store_instruction jmp instruction_assembled amd_prefetch_instruction: mov [extended_code],0Dh jmp prefetch_mem_8bit fence_instruction: mov bl,al mov ax,0AE0Fh stos word [edi] mov al,bl stos byte [edi] jmp instruction_assembled pause_instruction: mov ax,90F3h stos word [edi] jmp instruction_assembled movntq_instruction: mov [mmx_size],8 jmp movnt_instruction movntps_instruction: mov [mmx_size],16 jmp movnt_instruction movntdq_instruction: mov [operand_prefix],66h mov [mmx_size],16 movnt_instruction: mov [extended_code],al mov [base_code],0Fh lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address 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_mmx_register cmp ah,[mmx_size] jne invalid_operand_size mov [postbyte_register],al call store_instruction jmp instruction_assembled movnti_instruction: mov [base_code],0Fh mov [extended_code],al lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address 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_register cmp ah,4 je movnti_store cmp ah,8 jne invalid_operand_size call operand_64bit movnti_store: mov [postbyte_register],al call store_instruction jmp instruction_assembled monitor_instruction: mov [postbyte_register],al lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register cmp ax,0400h jne invalid_operand 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_register cmp ax,0401h jne invalid_operand cmp [postbyte_register],0C8h jne monitor_instruction_store 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_register cmp ax,0402h jne invalid_operand monitor_instruction_store: mov ax,010Fh stos word [edi] mov al,[postbyte_register] stos byte [edi] jmp instruction_assembled simple_vmx_instruction: mov ah,al mov al,0Fh stos byte [edi] mov al,1 stos word [edi] jmp instruction_assembled vmclear_instruction: mov [operand_prefix],66h jmp vmx_instruction vmxon_instruction: mov [operand_prefix],0F3h vmx_instruction: mov [postbyte_register],al mov [extended_code],0C7h lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address mov al,[operand_size] or al,al jz vmx_size_ok cmp al,8 jne invalid_operand_size vmx_size_ok: mov [base_code],0Fh call store_instruction jmp instruction_assembled vmread_instruction: mov [extended_code],78h lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address 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_register mov [postbyte_register],al vmread_check_size: cmp [code_type],64 je vmread_long cmp [operand_size],4 je vmx_size_ok jmp invalid_operand_size vmread_long: cmp [operand_size],8 je vmx_size_ok jmp invalid_operand_size vmwrite_instruction: mov [extended_code],79h 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 lods byte [esi] call get_size_operator cmp al,'[' jne invalid_operand call get_address jmp vmread_check_size simple_svm_instruction: push eax mov [base_code],0Fh mov [extended_code],1 lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register or al,al jnz invalid_operand simple_svm_detect_size: cmp ah,2 je simple_svm_16bit cmp ah,4 je simple_svm_32bit cmp [code_type],64 jne invalid_operand_size jmp simple_svm_store simple_svm_16bit: cmp [code_type],16 je simple_svm_store cmp [code_type],64 je invalid_operand_size jmp prefixed_svm_store simple_svm_32bit: cmp [code_type],32 je simple_svm_store prefixed_svm_store: mov al,67h stos byte [edi] simple_svm_store: call store_instruction_code pop eax stos byte [edi] jmp instruction_assembled skinit_instruction: lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register cmp ax,0400h jne invalid_operand mov al,0DEh jmp simple_vmx_instruction invlpga_instruction: push eax mov [base_code],0Fh mov [extended_code],1 lods byte [esi] call get_size_operator cmp al,10h jne invalid_operand lods byte [esi] call convert_register or al,al jnz invalid_operand mov bl,ah 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_register cmp ax,0401h jne invalid_operand mov ah,bl jmp simple_svm_detect_size convert_register: mov ah,al shr ah,4 and al,0Fh cmp ah,8 je match_register_size cmp ah,4 ja invalid_operand cmp ah,1 ja match_register_size cmp al,4 jb match_register_size or ah,ah jz high_byte_register or [rex_prefix],40h match_register_size: cmp ah,[operand_size] je register_size_ok cmp [operand_size],0 jne operand_sizes_do_not_match mov [operand_size],ah register_size_ok: ret high_byte_register: mov ah,1 or [rex_prefix],80h jmp match_register_size convert_fpu_register: mov ah,al shr ah,4 and al,111b cmp ah,10 jne invalid_operand jmp match_register_size convert_mmx_register: mov ah,al shr ah,4 cmp ah,0Ch je xmm_register ja invalid_operand and al,111b cmp ah,0Bh jne invalid_operand mov ah,8 jmp match_register_size xmm_register: and al,0Fh mov ah,16 cmp al,8 jb match_register_size cmp [code_type],64 jne invalid_operand jmp match_register_size get_size_operator: xor ah,ah cmp al,11h jne no_size_operator mov [size_declared],1 lods word [esi] xchg al,ah mov [size_override],1 cmp ah,[operand_size] je size_operator_ok cmp [operand_size],0 jne operand_sizes_do_not_match mov [operand_size],ah size_operator_ok: ret no_size_operator: mov [size_declared],0 cmp al,'[' jne size_operator_ok mov [size_override],0 ret get_jump_operator: mov [jump_type],0 cmp al,12h jne jump_operator_ok lods word [esi] mov [jump_type],al mov al,ah jump_operator_ok: ret get_address: mov [segment_register],0 mov [address_size],0 mov al,[code_type] shr al,3 mov [value_size],al mov al,[esi] and al,11110000b cmp al,60h jne get_size_prefix lods byte [esi] sub al,60h mov [segment_register],al mov al,[esi] and al,11110000b get_size_prefix: cmp al,70h jne address_size_prefix_ok lods byte [esi] sub al,70h cmp al,2 jb invalid_address_size cmp al,8 ja invalid_address_size mov [address_size],al mov [value_size],al address_size_prefix_ok: call calculate_address cmp byte [esi-1],']' jne invalid_address mov [address_high],edx mov edx,eax cmp [code_type],64 jne address_ok or bx,bx jnz address_ok test ch,0Fh jnz address_ok calculate_relative_address: mov edx,[address_symbol] mov [symbol_identifier],edx mov edx,[address_high] call calculate_relative_offset mov [address_high],edx cdq cmp edx,[address_high] jne value_out_of_range mov edx,eax ror ecx,16 mov cl,[value_type] rol ecx,16 mov bx,0FF00h address_ok: ret operand_16bit: cmp [code_type],16 je size_prefix_ok mov [operand_prefix],66h ret operand_32bit: cmp [code_type],16 jne size_prefix_ok mov [operand_prefix],66h size_prefix_ok: ret operand_64bit: cmp [code_type],64 jne illegal_instruction or [rex_prefix],48h ret operand_autodetect: cmp al,2 je operand_16bit cmp al,4 je operand_32bit cmp al,8 je operand_64bit jmp invalid_operand_size store_segment_prefix_if_necessary: mov al,[segment_register] or al,al jz segment_prefix_ok cmp al,3 je ss_prefix cmp al,4 ja segment_prefix_386 jb segment_prefix_86 cmp bl,25h je segment_prefix_86 cmp bh,25h je segment_prefix_86 cmp bh,45h je segment_prefix_86 cmp bh,44h je segment_prefix_86 ret ss_prefix: cmp bl,25h je segment_prefix_ok cmp bh,25h je segment_prefix_ok cmp bh,45h je segment_prefix_ok cmp bh,44h je segment_prefix_ok jmp segment_prefix_86 store_segment_prefix: mov al,[segment_register] or al,al jz segment_prefix_ok cmp al,5 jae segment_prefix_386 segment_prefix_86: dec al shl al,3 add al,26h stos byte [edi] jmp segment_prefix_ok segment_prefix_386: add al,64h-5 stos byte [edi] segment_prefix_ok: ret store_instruction_code: mov al,[operand_prefix] or al,al jz operand_prefix_ok stos byte [edi] operand_prefix_ok: mov al,[rex_prefix] test al,40h jz rex_prefix_ok cmp [code_type],64 jne invalid_operand test al,0B0h jnz prefix_conflict stos byte [edi] rex_prefix_ok: mov al,[base_code] stos byte [edi] cmp al,0Fh jne instruction_code_ok store_extended_code: mov al,[extended_code] stos byte [edi] cmp al,38h je store_supplemental_code cmp al,3Ah je store_supplemental_code instruction_code_ok: ret store_supplemental_code: mov al,[supplemental_code] stos byte [edi] ret store_nomem_instruction: test [postbyte_register],1000b jz nomem_reg_code_ok or [rex_prefix],44h and [postbyte_register],111b nomem_reg_code_ok: test bl,1000b jz nomem_rm_code_ok or [rex_prefix],41h and bl,111b nomem_rm_code_ok: call store_instruction_code mov al,[postbyte_register] shl al,3 or al,bl or al,11000000b stos byte [edi] ret store_instruction: mov [current_offset],edi test [postbyte_register],1000b jz reg_code_ok or [rex_prefix],44h and [postbyte_register],111b reg_code_ok: call store_segment_prefix_if_necessary or bx,bx jz address_immediate cmp bx,0F800h je address_rip_based cmp bx,0F400h je address_eip_based cmp bx,0FF00h je address_relative mov al,bl or al,bh and al,11110000b cmp al,80h je postbyte_64bit cmp al,40h je postbyte_32bit cmp al,20h jne invalid_address cmp [code_type],64 je invalid_address_size call address_16bit_prefix call store_instruction_code cmp bx,2326h je address_bx_si cmp bx,2623h je address_bx_si cmp bx,2327h je address_bx_di cmp bx,2723h je address_bx_di cmp bx,2526h je address_bp_si cmp bx,2625h je address_bp_si cmp bx,2527h je address_bp_di cmp bx,2725h je address_bp_di cmp bx,2600h je address_si cmp bx,2700h je address_di cmp bx,2300h je address_bx cmp bx,2500h je address_bp jmp invalid_address address_bx_si: xor al,al jmp postbyte_16bit address_bx_di: mov al,1 jmp postbyte_16bit address_bp_si: mov al,10b jmp postbyte_16bit address_bp_di: mov al,11b jmp postbyte_16bit address_si: mov al,100b jmp postbyte_16bit address_di: mov al,101b jmp postbyte_16bit address_bx: mov al,111b jmp postbyte_16bit address_bp: mov al,110b postbyte_16bit: test ch,22h jnz address_16bit_value or ch,ch jnz address_sizes_do_not_agree cmp edx,10000h jge value_out_of_range cmp edx,-8000h jl value_out_of_range or dx,dx jz address cmp dx,80h jb address_8bit_value cmp dx,-80h jae address_8bit_value address_16bit_value: or al,10000000b mov cl,[postbyte_register] shl cl,3 or al,cl stos byte [edi] mov eax,edx stos word [edi] ret address_8bit_value: or al,01000000b mov cl,[postbyte_register] shl cl,3 or al,cl stos byte [edi] mov al,dl stos byte [edi] cmp dx,80h jge value_out_of_range cmp dx,-80h jl value_out_of_range ret address: cmp al,110b je address_8bit_value mov cl,[postbyte_register] shl cl,3 or al,cl stos byte [edi] ret postbyte_32bit: call address_32bit_prefix jmp address_prefix_ok postbyte_64bit: cmp [code_type],64 jne invalid_address_size address_prefix_ok: test bh,1000b jz base_code_ok or [rex_prefix],41h base_code_ok: test bl,1000b jz index_code_ok or [rex_prefix],42h index_code_ok: call store_instruction_code cmp bl,44h je swap_base_with_index cmp bl,84h jne base_register_ok swap_base_with_index: cmp cl,1 jne invalid_address xchg bl,bh cmp bl,44h je invalid_address cmp bl,84h je invalid_address base_register_ok: or cl,cl jz only_base_register base_and_index: mov al,100b xor ah,ah cmp cl,1 je scale_ok cmp cl,2 je scale_1 cmp cl,4 je scale_2 or ah,11000000b jmp scale_ok scale_2: or ah,10000000b jmp scale_ok scale_1: or ah,01000000b scale_ok: or bh,bh jz only_index_register and bl,111b shl bl,3 or ah,bl and bh,111b or ah,bh test ch,44h jnz sib_address_32bit_value test ch,88h jnz sib_address_32bit_value or ch,ch jnz address_sizes_do_not_agree cmp bh,5 je address_value or edx,edx jz sib_address address_value: cmp edx,80h jb sib_address_8bit_value cmp edx,-80h jae sib_address_8bit_value sib_address_32bit_value: or al,10000000b mov cl,[postbyte_register] shl cl,3 or al,cl stos word [edi] address_32bit_value: cmp [code_type],64 jne store_address_32bit_value mov eax,edx cdq cmp edx,[address_high] jne value_out_of_range mov edx,eax jmp store_address_32bit_value sib_address_8bit_value: or al,01000000b mov cl,[postbyte_register] shl cl,3 or al,cl stos word [edi] mov al,dl stos byte [edi] cmp edx,80h jge value_out_of_range cmp edx,-80h jl value_out_of_range ret sib_address: mov cl,[postbyte_register] shl cl,3 or al,cl stos word [edi] ret only_index_register: or ah,101b and bl,111b shl bl,3 or ah,bl mov cl,[postbyte_register] shl cl,3 or al,cl stos word [edi] test ch,44h jnz address_32bit_value test ch,88h jnz address_32bit_value or ch,ch jnz invalid_address_size jmp address_32bit_value zero_index_register: mov bl,4 mov cl,1 jmp base_and_index only_base_register: mov al,bh and al,111b cmp al,4 je zero_index_register test ch,44h jnz simple_address_32bit_value test ch,88h jnz simple_address_32bit_value or ch,ch jnz address_sizes_do_not_agree or edx,edx jz simple_address cmp edx,80h jb simple_address_8bit_value cmp edx,-80h jae simple_address_8bit_value simple_address_32bit_value: or al,10000000b mov cl,[postbyte_register] shl cl,3 or al,cl stos byte [edi] jmp address_32bit_value simple_address_8bit_value: or al,01000000b mov cl,[postbyte_register] shl cl,3 or al,cl stos byte [edi] mov al,dl stos byte [edi] cmp edx,80h jge value_out_of_range cmp edx,-80h jl value_out_of_range ret simple_address: cmp al,5 je simple_address_8bit_value mov cl,[postbyte_register] shl cl,3 or al,cl stos byte [edi] ret address_immediate: cmp [code_type],64 je address_immediate_sib test ch,44h jnz address_immediate_32bit test ch,22h jnz address_immediate_16bit or ch,ch jnz invalid_address_size cmp [code_type],16 je addressing_16bit address_immediate_32bit: call address_32bit_prefix call store_instruction_code store_immediate_address: mov al,101b mov cl,[postbyte_register] shl cl,3 or al,cl stos byte [edi] store_address_32bit_value: test ch,0F0h jz address_32bit_relocation_ok mov eax,ecx shr eax,16 cmp al,4 jne address_32bit_relocation mov al,2 address_32bit_relocation: xchg [value_type],al mov ebx,[address_symbol] xchg ebx,[symbol_identifier] call mark_relocation mov [value_type],al mov [symbol_identifier],ebx address_32bit_relocation_ok: mov eax,edx stos dword [edi] ret store_address_64bit_value: test ch,0F0h jz address_64bit_relocation_ok mov eax,ecx shr eax,16 xchg [value_type],al mov ebx,[address_symbol] xchg ebx,[symbol_identifier] call mark_relocation mov [value_type],al mov [symbol_identifier],ebx address_64bit_relocation_ok: mov eax,edx stos dword [edi] mov eax,[address_high] stos dword [edi] ret address_immediate_sib: test ch,not 44h jnz invalid_address_size test ecx,0FF0000h jnz address_immediate_sib_nosignextend test edx,80000000h jz address_immediate_sib_prefix_ok address_immediate_sib_nosignextend: call address_32bit_prefix address_immediate_sib_prefix_ok: call store_instruction_code mov al,100b mov ah,100101b mov cl,[postbyte_register] shl cl,3 or al,cl stos word [edi] jmp store_address_32bit_value address_eip_based: mov al,67h stos byte [edi] address_rip_based: cmp [code_type],64 jne invalid_address call store_instruction_code jmp store_immediate_address address_relative: call store_instruction_code movzx eax,[immediate_size] add eax,edi sub eax,[current_offset] add eax,5 sub edx,eax jo value_out_of_range mov al,101b mov cl,[postbyte_register] shl cl,3 or al,cl stos byte [edi] shr ecx,16 xchg [value_type],cl mov ebx,[address_symbol] xchg ebx,[symbol_identifier] mov eax,edx call mark_relocation mov [value_type],cl mov [symbol_identifier],ebx stos dword [edi] ret addressing_16bit: cmp edx,10000h jge address_immediate_32bit cmp edx,-8000h jl address_immediate_32bit movzx edx,dx address_immediate_16bit: call address_16bit_prefix call store_instruction_code mov al,110b mov cl,[postbyte_register] shl cl,3 or al,cl stos byte [edi] mov eax,edx stos word [edi] cmp edx,10000h jge value_out_of_range cmp edx,-8000h jl value_out_of_range ret address_16bit_prefix: cmp [code_type],16 je instruction_prefix_ok mov al,67h stos byte [edi] ret address_32bit_prefix: cmp [code_type],32 je instruction_prefix_ok mov al,67h stos byte [edi] instruction_prefix_ok: ret store_instruction_with_imm8: mov [immediate_size],1 call store_instruction mov al,byte [value] stos byte [edi] ret store_instruction_with_imm16: mov [immediate_size],2 call store_instruction mov ax,word [value] call mark_relocation stos word [edi] ret store_instruction_with_imm32: mov [immediate_size],4 call store_instruction mov eax,dword [value] call mark_relocation stos dword [edi] ret