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