| 0,0 → 1,6495 |
|---|
| |
| ; flat assembler core |
| ; Copyright (c) 1999-2006, 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: |
| 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 bx cx |
| 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 cx bx 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 cx bx 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 cx bx 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 cx bx 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 |
| 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 bx cx |
| 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 cx bx 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 cx bx 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 cx bx 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 cx bx 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 cx bx 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 bx cx |
| 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 cx bx 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 cx bx 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 cx bx 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 cx bx 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 bx cx |
| 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 |
| 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 |
| 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 bx cx |
| 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 cx bx 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 cx bx 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 bx cx |
| 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 cx bx 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 cx bx 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 bx cx |
| 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 cx bx 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 cx bx 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 bx cx |
| cmp byte [esi],',' |
| je imul_reg_mem_imm |
| mov al,[operand_size] |
| call operand_autodetect |
| pop cx bx 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 cx bx 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 cx bx 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 cx bx 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_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_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_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: |
| cmp [value_undefined],0 |
| jne jump_offset_ok |
| add eax,dword [org_origin] |
| adc edx,dword [org_origin+4] |
| lea ebx,[edi+2] |
| sub eax,ebx |
| sbb edx,0 |
| mov bl,[value_type] |
| or bl,bl |
| je jump_offset_ok |
| test bl,1 |
| jnz invalid_use_of_symbol |
| cmp bl,[labels_type] |
| jne invalid_use_of_symbol |
| mov [value_type],0 |
| mov ecx,[symbol_identifier] |
| cmp ecx,[org_symbol] |
| je jump_offset_ok |
| mov [value_type],3 |
| jump_offset_ok: |
| 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_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_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_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_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_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_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 ax bx |
| 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 dx ax |
| 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 bx cx |
| 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 cx bx 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 |
| |
| 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 |
| |
| mmx_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 |
| 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 bx cx 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 cx bx |
| 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 |
| 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 bx cx edx |
| call get_nextbyte |
| pop edx cx bx |
| 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 |
| 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: |
| call calculate_relative_offset |
| cmp byte [esi-1],']' |
| jne invalid_address |
| mov [address_high],edx |
| mov edx,[symbol_identifier] |
| mov [address_symbol],edx |
| mov edx,eax |
| mov ch,[value_type] |
| mov bx,0FF00h |
| xor cl,cl |
| 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] |
| instruction_code_ok: |
| 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,0F000h |
| je address_rip_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] |
| 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 store_address_32bit_value |
| or ch,ch |
| jnz invalid_address_size |
| jmp store_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 store_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 al,2 |
| 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 al,4 |
| 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 |
| cmp [value_type],0 |
| jne 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_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] |
| xchg [value_type],ch |
| mov ebx,[address_symbol] |
| xchg ebx,[symbol_identifier] |
| mov eax,edx |
| call mark_relocation |
| mov [value_type],ch |
| 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 |
| Property changes: |
|---|
| Added: svn:eol-style |
|---|
| +native |
|---|
| \ No newline at end of property |
|---|