WebSVN – Kolibri OS – Diff – /programs/develop/fasm/trunk/x86_64.inc

 ; flat assembler core
-; Copyright (c) 1999-2013, Tomasz Grysztar.
+; Copyright (c) 1999-2016, Tomasz Grysztar.
 ; All rights reserved.
 simple_instruction_except64:
 	cmp	[code_type],64
 	stos	word [edi]
 	jmp	instruction_assembled
 prefix_instruction:
 	stos	byte [edi]
-	or	[prefixed_instruction],-1
+	or	[prefix_flags],1
 	jmp	continue_line
 segment_prefix:
 	mov	ah,al
 	shr	ah,4
-	cmp	ah,6
+	cmp	ah,3
 	jne	illegal_instruction
 	and	al,1111b
 	mov	[segment_register],al
 	call	store_segment_prefix
-	or	[prefixed_instruction],-1
+	or	[prefix_flags],1
+	jmp	continue_line
+bnd_prefix_instruction:
-	jmp	continue_line
+	stos	byte [edi]
+	or	[prefix_flags],1 + 10h
+	jmp	continue_line
 int_instruction:
 	lods	byte [esi]
 	call	get_size_operator
 	cmp	ah,1
 	ja	invalid_operand_size
 	stos	byte [edi]
 	jmp	instruction_assembled
       basic_ax_imm:
 	add	[base_code],5
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	basic_store_imm_16bit
       basic_reg_imm_32bit:
 	call	operand_32bit
 	call	get_dword_value
       basic_reg_imm_32bit_ok:
 	mov	edx,eax
 	stos	dword [edi]
 	jmp	instruction_assembled
       basic_eax_imm:
 	add	[base_code],5
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	basic_store_imm_32bit
       recoverable_unknown_size:
 	cmp	[error_line],0
 	jne	ignore_unknown_size
 	push	[current_line]
 	pop	[error_line]
 	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	je	mov_reg
-	cmp	al,'['
+	cmp	al,14h
+	je	mov_creg
+	cmp	al,'['
 	jne	invalid_operand
       mov_mem:
 	call	get_address
 	push	edx ebx ecx
 	lods	byte [esi]
 	cmp	al,10h
 	jne	invalid_operand
       mov_mem_reg:
 	lods	byte [esi]
-	cmp	al,60h
+	cmp	al,30h
 	jb	mov_mem_general_reg
-	cmp	al,70h
+	cmp	al,40h
 	jb	mov_mem_sreg
       mov_mem_general_reg:
 	call	convert_register
 	mov	[postbyte_register],al
 	pop	ecx ebx edx
 	cmp	ah,1
 	call	store_segment_prefix_if_necessary
 	call	address_32bit_prefix
 	mov	[base_code],0A2h
       store_mov_address32:
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	call	store_address_32bit_value
 	jmp	instruction_assembled
       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
+	call	store_classic_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
+	call	store_classic_instruction_code
 	call	store_address_64bit_value
 	jmp	instruction_assembled
       mov_mem_ax:
 	test	ch,22h
 	jnz	mov_mem_address16_ax
 	test	ch,44h
 	call	store_segment_prefix_if_necessary
 	mov	[base_code],0A3h
 	jmp	store_mov_address64
       mov_mem_sreg:
-	sub	al,61h
+	sub	al,31h
 	mov	[postbyte_register],al
 	pop	ecx ebx edx
 	mov	ah,[operand_size]
 	or	ah,ah
 	jz	mov_mem_sreg_store
 	cmp	ah,2
 	call	get_simm32
 	cmp	[value_type],4
 	jae	long_immediate_not_encodable
 	jmp	mov_mem_imm_32bit_store
-      mov_mem_imm_8bit:
+      mov_mem_imm_nosize:
+	call	recoverable_unknown_size
+      mov_mem_imm_8bit:
 	call	get_byte_value
 	mov	byte [value],al
 	mov	[postbyte_register],0
 	mov	[base_code],0C6h
 	pop	ecx ebx edx
 	mov	[base_code],0C7h
 	pop	ecx ebx edx
 	call	store_instruction_with_imm16
 	jmp	instruction_assembled
-      mov_mem_imm_nosize:
+      mov_mem_imm_32bit:
-	call	recoverable_unknown_size
-      mov_mem_imm_32bit:
 	call	operand_32bit
 	call	get_dword_value
       mov_mem_imm_32bit_store:
 	mov	dword [value],eax
 	mov	[postbyte_register],0
 	cmp	al,'['
 	je	mov_reg_mem
 	cmp	al,'('
 	je	mov_reg_imm
-	cmp	al,10h
+	cmp	al,14h
+	je	mov_reg_creg
+	cmp	al,10h
 	jne	invalid_operand
       mov_reg_reg:
 	lods	byte [esi]
 	mov	ah,al
 	sub	ah,10h
 	mov	ah,al
 	and	al,1111b
 	mov	[postbyte_register],al
 	shr	ah,4
-	cmp	ah,5
+	cmp	ah,3
-	je	mov_reg_creg
+	jne	invalid_operand
-	cmp	ah,7
-	je	mov_reg_dreg
-	ja	mov_reg_treg
+	dec	[postbyte_register]
-	dec	[postbyte_register]
 	cmp	[operand_size],8
 	je	mov_reg_sreg64
 	cmp	[operand_size],4
 	je	mov_reg_sreg32
 	cmp	[operand_size],2
 	call	operand_32bit
       mov_reg_sreg_store:
 	mov	[base_code],8Ch
 	jmp	nomem_instruction_ready
-      mov_reg_treg:
+      mov_reg_creg:
-	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
+	lods	byte [esi]
+	mov	bl,al
+	shr	al,4
+	cmp	al,4
+	ja	invalid_operand
+	add	al,20h
+	mov	[extended_code],al
-      mov_reg_xrx:
+	and	bl,1111b
+	xchg	bl,[postbyte_register]
 	mov	[base_code],0Fh
 	cmp	[code_type],64
-	je	mov_reg_xrx_64bit
+	je	mov_reg_creg_64bit
 	cmp	[operand_size],4
 	jne	invalid_operand_size
 	cmp	[postbyte_register],8
-	jne	mov_reg_xrx_store
+	jb	mov_reg_creg_store
 	cmp	[extended_code],20h
-	jne	mov_reg_xrx_store
+	jne	mov_reg_creg_store
 	mov	al,0F0h
 	stos	byte [edi]
 	mov	[postbyte_register],0
-      mov_reg_xrx_store:
+      mov_reg_creg_store:
 	jmp	nomem_instruction_ready
-      mov_reg_xrx_64bit:
+      mov_reg_creg_64bit:
 	cmp	[operand_size],8
 	jne	invalid_operand_size
 	jmp	nomem_instruction_ready
       mov_reg_mem:
 	call	get_address
 	mov	al,[operand_size]
       mov_reg_imm_prefix_ok:
 	and	ah,111b
 	add	al,ah
 	mov	[base_code],al
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	ret
       mov_reg_64bit_imm_32bit:
 	mov	edx,eax
 	mov	bl,[postbyte_register]
 	mov	[postbyte_register],0
 	mov	[base_code],0C7h
 	mov	ah,al
 	and	al,1111b
 	mov	[postbyte_register],al
 	shr	ah,4
-	cmp	ah,5
+	cmp	ah,3
-	je	mov_creg
+	jne	invalid_operand
-	cmp	ah,7
-	je	mov_dreg
-	ja	mov_treg
+	cmp	al,2
-	cmp	al,2
 	je	illegal_instruction
 	dec	[postbyte_register]
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
 	jne	invalid_operand_size
       mov_sreg_mem_size_ok:
 	mov	[base_code],8Eh
 	jmp	instruction_ready
-      mov_treg:
+      mov_creg:
-	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
+	lods	byte [esi]
+	mov	ah,al
+	shr	ah,4
+	cmp	ah,4
+	ja	invalid_operand
+	add	ah,22h
+	mov	[extended_code],ah
-      mov_xrx:
+	and	al,1111b
-	mov	[base_code],0Fh
+	mov	[postbyte_register],al
+	mov	[base_code],0Fh
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	mov	bl,al
 	cmp	[code_type],64
-	je	mov_xrx_64bit
+	je	mov_creg_64bit
 	cmp	ah,4
 	jne	invalid_operand_size
 	cmp	[postbyte_register],8
-	jne	mov_xrx_store
+	jb	mov_creg_store
 	cmp	[extended_code],22h
-	jne	mov_xrx_store
+	jne	mov_creg_store
 	mov	al,0F0h
 	stos	byte [edi]
 	mov	[postbyte_register],0
-      mov_xrx_store:
+      mov_creg_store:
 	jmp	nomem_instruction_ready
-      mov_xrx_64bit:
+      mov_creg_64bit:
 	cmp	ah,8
-	je	mov_xrx_store
+	je	mov_creg_store
 	jmp	invalid_operand_size
 test_instruction:
 	mov	[base_code],84h
 	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	call	get_simm32
 	cmp	[value_type],4
 	jae	long_immediate_not_encodable
 	jmp	test_mem_imm_32bit_store
-      test_mem_imm_8bit:
+      test_mem_imm_nosize:
+	call	recoverable_unknown_size
+      test_mem_imm_8bit:
 	call	get_byte_value
 	mov	byte [value],al
 	mov	[postbyte_register],0
 	mov	[base_code],0F6h
 	pop	ecx ebx edx
 	mov	[base_code],0F7h
 	pop	ecx ebx edx
 	call	store_instruction_with_imm16
 	jmp	instruction_assembled
-      test_mem_imm_nosize:
+      test_mem_imm_32bit:
-	call	recoverable_unknown_size
-      test_mem_imm_32bit:
 	call	operand_32bit
 	call	get_dword_value
       test_mem_imm_32bit_store:
 	mov	dword [value],eax
 	mov	[postbyte_register],0
 	stos	byte [edi]
 	jmp	instruction_assembled
       test_al_imm:
 	mov	[base_code],0A8h
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	mov	al,dl
 	stos	byte [edi]
 	jmp	instruction_assembled
       test_reg_imm_16bit:
 	call	operand_16bit
 	call	get_word_value
 	stos	word [edi]
 	jmp	instruction_assembled
       test_ax_imm:
 	mov	[base_code],0A9h
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	mov	ax,dx
 	stos	word [edi]
 	jmp	instruction_assembled
       test_reg_imm_32bit:
 	call	operand_32bit
 	call	get_dword_value
 	stos	dword [edi]
 	jmp	instruction_assembled
       test_eax_imm:
 	mov	[base_code],0A9h
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	mov	eax,edx
 	stos	dword [edi]
 	jmp	instruction_assembled
       test_reg_mem:
 	call	get_address
 	mov	al,[operand_size]
 	and	bl,111b
       xchg_ax_reg_store:
 	add	bl,90h
 	mov	[base_code],bl
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	instruction_assembled
       xchg_reg_reg_store:
 	inc	[base_code]
       xchg_reg_reg_8bit:
 	jmp	nomem_instruction_ready
 push_instruction:
 	test	ah,not 2
 	jnz	invalid_operand_size
 	call	operand_16bit
       push_reg_store:
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	push_done
       push_sreg:
 	mov	bl,al
 	mov	dl,[operand_size]
 	mov	dh,[push_size]
 	cmp	dl,2
 	cmp	[code_type],64
 	jne	illegal_instruction
       push_sreg_store:
 	mov	al,bl
-	cmp	al,70h
+	cmp	al,40h
 	jae	invalid_operand
-	sub	al,61h
+	sub	al,31h
 	jc	invalid_operand
 	cmp	al,4
 	jae	push_sreg_386
 	shl	al,3
 	add	al,6
 	mov	[base_code],al
 	jge	push_imm_16bit_store
       push_imm_8bit:
 	mov	ah,al
 	mov	[base_code],6Ah
-	call	store_instruction_code
+	call	store_classic_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
+	call	store_classic_instruction_code
 	mov	ax,dx
 	call	mark_relocation
 	stos	word [edi]
 	jmp	push_done
       push_imm_64bit:
 	cmp	[code_type],64
 	mov	edx,eax
 	call	operand_32bit
       push_imm_32bit_store:
 	mov	[base_code],68h
-	call	store_instruction_code
+	call	store_classic_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	 [operand_size],0
-	mov	[size_override],0
+;	 mov	 [operand_flags],0
-	mov	[operand_prefix],0
+;	 mov	 [operand_prefix],0
-	mov	[rex_prefix],0
+;	 mov	 [rex_prefix],0
-	jmp	push_next
+	and	dword [operand_size],0
+	jmp	push_next
 pop_instruction:
 	mov	[push_size],al
       pop_next:
 	lods	byte [esi]
 	call	get_size_operator
 	test	ah,not 2
 	jnz	invalid_operand_size
 	call	operand_16bit
       pop_reg_store:
-	call	store_instruction_code
+	call	store_classic_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	 [operand_size],0
-	mov	[size_override],0
+;	 mov	 [operand_flags],0
-	mov	[operand_prefix],0
+;	 mov	 [operand_prefix],0
-	mov	[rex_prefix],0
+;	 mov	 [rex_prefix],0
-	jmp	pop_next
+	and	dword [operand_size],0
+	jmp	pop_next
       pop_sreg:
 	mov	dl,[operand_size]
 	mov	dh,[push_size]
-	cmp	al,62h
+	cmp	al,32h
 	je	pop_cs
 	mov	bl,al
 	cmp	dl,2
 	je	pop_sreg16
 	cmp	dl,4
 	je	pop_sreg32
 	cmp	[code_type],64
 	jne	illegal_instruction
       pop_sreg_store:
 	mov	al,bl
-	cmp	al,70h
+	cmp	al,40h
 	jae	invalid_operand
-	sub	al,61h
+	sub	al,31h
 	jc	invalid_operand
 	cmp	al,4
 	jae	pop_sreg_386
 	shl	al,3
 	add	al,7
 	mov	[base_code],al
 	shl	al,3
 	add	al,bl
 	add	al,40h
 	mov	[base_code],al
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	instruction_assembled
       inc_reg_long_form:
 	inc	[base_code]
       inc_reg_8bit:
 	jmp	nomem_instruction_ready
 set_instruction:
 	call	get_address
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	mov	[postbyte_register],al
 	cmp	ah,2
 	jne	invalid_operand_size
 	jmp	instruction_ready
       arpl_reg:
 	lods	byte [esi]
 	mov	bl,al
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	mov	[postbyte_register],al
 	jmp	nomem_instruction_ready
 bound_instruction:
 	cmp	[code_type],64
 	je	illegal_instruction
-	lods	byte [esi]
+	call	take_register
-	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
 	jmp	ret_instruction
 ret_instruction_16bit:
 	call	operand_16bit
 	jmp	ret_instruction
-retf_instruction:
+ret_instruction_64bit:
-	cmp	[code_type],64
-	jne	ret_instruction
-ret_instruction_64bit:
 	call	operand_64bit
 ret_instruction:
-	mov	[base_code],al
+	and	[prefix_flags],not 10h
+      ret_common:
+	mov	[base_code],al
 	lods	byte [esi]
 	dec	esi
 	or	al,al
 	jz	simple_ret
 	cmp	al,0Fh
 	or	ax,ax
 	jz	simple_ret
       ret_imm_store:
 	mov	dx,ax
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	mov	ax,dx
 	stos	word [edi]
 	jmp	instruction_assembled
       simple_ret:
 	inc	[base_code]
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	instruction_assembled
-lea_instruction:
+retf_instruction:
+	cmp	[code_type],64
+	jne	ret_common
+retf_instruction_64bit:
+	call	operand_64bit
+	jmp	ret_common
+retf_instruction_32bit:
+	call	operand_32bit
+	jmp	ret_common
+retf_instruction_16bit:
+	call	operand_16bit
+	jmp	ret_common
+lea_instruction:
 	mov	[base_code],8Dh
-	lods	byte [esi]
+	call	take_register
-	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]
 	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,'['
 	jne	invalid_operand
-	mov	[size_override],-1
+	or	[operand_flags],1
 	call	get_address
 	pop	eax
 	mov	[operand_size],al
 	call	operand_autodetect
 	jmp	instruction_ready
 ls_instruction:
       ls_short_code:
 	cmp	[code_type],64
 	je	illegal_instruction
       ls_code_ok:
-	lods	byte [esi]
+	call	take_register
-	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]
 	push	edx ebx ecx
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	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
 	mov	[postbyte_register],al
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	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,','
 	jmp	instruction_assembled
 movx_instruction:
 	mov	[base_code],0Fh
 	mov	[extended_code],al
-	lods	byte [esi]
+	call	take_register
-	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
 	inc	[extended_code]
 	jmp	nomem_instruction_ready
 movsxd_instruction:
 	mov	[base_code],al
-	lods	byte [esi]
+	call	take_register
-	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
 	jne	bt_mem_reg
 	cmp	byte [esi+2],'('
 	je	bt_mem_imm
       bt_mem_reg:
-	lods	byte [esi]
+	call	take_register
-	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
 	jmp	instruction_ready
       bt_mem_imm:
 	jne	bt_reg_reg
 	cmp	byte [esi+2],'('
 	je	bt_reg_imm
       bt_reg_reg:
-	lods	byte [esi]
+	call	take_register
-	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
 	jmp	nomem_instruction_ready
       bt_reg_imm:
 	xor	al,al
 	mov	al,ah
 	call	operand_autodetect
 	jmp	nomem_instruction_ready
       get_reg_mem:
-	lods	byte [esi]
+	call	take_register
-	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
 	mov	al,dl
 	stos	byte [edi]
 	jmp	instruction_assembled
 in_instruction:
-	lods	byte [esi]
+	call	take_register
-	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
 	jne	invalid_operand_size
       in_ax_dx:
 	call	operand_autodetect
 	mov	[base_code],0EDh
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	instruction_assembled
       in_al_dx:
 	mov	al,0ECh
 	stos	byte [edi]
 	jmp	instruction_assembled
       in_imm:
 	jne	invalid_operand_size
       in_ax_imm:
 	call	operand_autodetect
 	mov	[base_code],0E5h
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	mov	al,dl
 	stos	byte [edi]
 	jmp	instruction_assembled
       in_al_imm:
 	mov	al,0E4h
 	stos	byte [edi]
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
 	mov	[operand_size],0
-	lods	byte [esi]
+	call	take_register
-	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
 	jne	invalid_operand_size
       out_dx_ax:
 	call	operand_autodetect
 	mov	[base_code],0EFh
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	instruction_assembled
       out_dx_al:
 	mov	al,0EEh
 	stos	byte [edi]
 	jmp	instruction_assembled
       out_imm:
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
 	mov	[operand_size],0
-	lods	byte [esi]
+	call	take_register
-	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
 	jne	invalid_operand_size
       out_imm_ax:
 	call	operand_autodetect
 	mov	[base_code],0E7h
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	mov	al,dl
 	stos	byte [edi]
 	jmp	instruction_assembled
       out_imm_al:
 	mov	al,0E6h
 	stos	byte [edi]
 	mov	[extended_code],0EAh
       process_jmp:
 	lods	byte [esi]
 	call	get_jump_operator
-	call	get_size_operator
+	test	[prefix_flags],10h
+	jz	jmp_type_ok
+	test	[jump_type],not 2
+	jnz	illegal_instruction
+	mov	[jump_type],2
+	and	[prefix_flags],not 10h
+      jmp_type_ok:
+	call	get_size_operator
 	cmp	al,'('
 	je	jmp_imm
 	mov	[base_code],0FFh
 	cmp	al,10h
 	je	jmp_reg
 	mov	edx,eax
 	sub	edx,3
 	jno	jmp_imm_32bit_ok
 	cmp	[code_type],64
-	je	relative_jump_out_of_range
+	je	jump_out_of_range
       jmp_imm_32bit_ok:
 	mov	al,[base_code]
 	stos	byte [edi]
 	mov	eax,edx
 	call	mark_relocation
 	stos	dword [edi]
 	call	calculate_jump_offset
 	mov	ecx,edx
 	cdq
 	cmp	edx,ecx
-	jne	relative_jump_out_of_range
+	jne	jump_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_far_16bit:
 	call	get_word_value
 	mov	ebx,eax
 	call	operand_16bit
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	mov	ax,bx
 	call	mark_relocation
 	stos	word [edi]
       jmp_far_segment:
 	pop	[symbol_identifier] eax
 	mov	[value_type],al
       jmp_far_32bit:
 	call	get_dword_value
 	mov	ebx,eax
 	call	operand_32bit
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	mov	eax,ebx
 	call	mark_relocation
 	stos	dword [edi]
 	jmp	jmp_far_segment
 conditional_jump:
 	mov	[base_code],al
-	lods	byte [esi]
+	and	[prefix_flags],not 10h
+	lods	byte [esi]
 	call	get_jump_operator
 	cmp	[jump_type],3
 	je	invalid_operand
 	call	get_size_operator
 	cmp	al,'('
 	mov	edx,eax
 	sub	edx,4
 	jno	conditional_jump_32bit_range_ok
 	cmp	[code_type],64
-	je	relative_jump_out_of_range
+	je	jump_out_of_range
       conditional_jump_32bit_range_ok:
 	mov	ah,[base_code]
 	add	ah,10h
 	mov	al,0Fh
 	stos	word [edi]
 	mov	eax,edx
 	call	calculate_jump_offset
 	mov	ecx,edx
 	cdq
 	cmp	edx,ecx
-	jne	relative_jump_out_of_range
+	jne	jump_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]
 	call	calculate_jump_offset
 	mov	ecx,edx
 	cdq
 	cmp	edx,ecx
-	jne	relative_jump_out_of_range
+	jne	jump_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
 	jmp	instruction_ready
 lar_instruction:
 	mov	[extended_code],al
 	mov	[base_code],0Fh
-	lods	byte [esi]
+	call	take_register
-	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]
 	jmp	instruction_ready
 swapgs_instruction:
 	cmp	[code_type],64
 	jne	illegal_instruction
-rdtscp_instruction:
+simple_instruction_0f_01:
-	mov	[base_code],0Fh
+	mov	ah,al
-	mov	[extended_code],1
+	mov	al,0Fh
-	mov	[postbyte_register],7
+	stos	byte [edi]
-	mov	bl,al
+	mov	al,1
-	jmp	nomem_instruction_ready
+	stos	word [edi]
+	jmp	instruction_assembled
 basic_486_instruction:
 	mov	[base_code],0Fh
 	mov	[extended_code],al
 	lods	byte [esi]
 	push	edx ebx ecx
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	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
 	mov	[postbyte_register],al
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	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:
 	jmp	nomem_instruction_ready
 bswap_instruction:
-	lods	byte [esi]
+	call	take_register
-	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
 	je	bswap_reg64
 	cmp	ah,4
 	jne	invalid_operand_size
 	call	operand_32bit
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	instruction_assembled
       bswap_reg64:
 	call	operand_64bit
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	jmp	instruction_assembled
 cmpxchgx_instruction:
 	mov	[base_code],0Fh
 	mov	[extended_code],0C7h
 	mov	[postbyte_register],al
 	lods	byte [esi]
 	jmp	instruction_assembled
 pmovmskb_instruction:
 	mov	[base_code],0Fh
 	mov	[extended_code],al
-	lods	byte [esi]
+	call	take_register
-	call	get_size_operator
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	cmp	ah,4
 	je	pmovmskb_reg_size_ok
 	cmp	[code_type],64
 	jne	invalid_operand_size
 	cmp	ah,8
 	jnz	invalid_operand_size
 	jne	invalid_operand
 	call	get_address
 	test	[operand_size],not 4
 	jnz	invalid_operand_size
-	mov	[operand_size],0
+	call	get_mmx_source_register
-	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
+	jmp	instruction_ready
-	mov	[postbyte_register],al
-	jmp	instruction_ready
       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
-	mov	bl,al
-	lods	byte [esi]
+	call	get_mmx_source_register
-	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
+	jmp	nomem_instruction_ready
-	call	make_mmx_prefix
-	jmp	nomem_instruction_ready
       movd_mmreg:
 	mov	[extended_code],6Eh
 	call	convert_mmx_register
-	call	make_mmx_prefix
+	mov	[postbyte_register],al
-	mov	[postbyte_register],al
-	mov	[operand_size],0
+	call	make_mmx_prefix
+	mov	[operand_size],0
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
 	lods	byte [esi]
 	call	get_size_operator
 	cmp	ah,4
 	jne	invalid_operand_size
 	mov	bl,al
 	jmp	nomem_instruction_ready
-      make_mmx_prefix:
+      get_mmx_source_register:
+	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	[postbyte_register],al
+      make_mmx_prefix:
-	cmp	[vex_required],0
+	cmp	[operand_size],16
-	jne	mmx_prefix_for_vex
-	cmp	[operand_size],16
 	jne	no_mmx_prefix
 	mov	[operand_prefix],66h
       no_mmx_prefix:
 	ret
-      mmx_prefix_for_vex:
+movq_instruction:
-	cmp	[operand_size],16
-	jne	invalid_operand
-	mov	[opcode_prefix],66h
-	ret
-movq_instruction:
 	mov	[base_code],0Fh
 	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	je	movq_reg
 	jne	invalid_operand
 	call	get_address
 	test	[operand_size],not 8
 	jnz	invalid_operand_size
-	mov	[operand_size],0
+	call	get_mmx_source_register
-	lods	byte [esi]
-	cmp	al,','
-	jne	invalid_operand
-	lods	byte [esi]
+	mov	al,7Fh
-	cmp	al,10h
-	jne	invalid_operand
+	cmp	ah,8
-	lods	byte [esi]
-	call	convert_mmx_register
-	mov	[postbyte_register],al
-	cmp	ah,16
-	je	movq_mem_xmmreg
+	je	movq_mem_ready
-	mov	[extended_code],7Fh
+	mov	al,0D6h
-	jmp	instruction_ready
+     movq_mem_ready:
-     movq_mem_xmmreg:
-	mov	[extended_code],0D6h
+	mov	[extended_code],al
-	mov	[opcode_prefix],66h
+	jmp	instruction_ready
-	jmp	instruction_ready
      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]
+	mov	[extended_code],7Eh
-	cmp	al,','
-	jne	invalid_operand
-	lods	byte [esi]
-	call	get_size_operator
-	cmp	al,10h
-	jne	invalid_operand
-	mov	[operand_size],0
-	lods	byte [esi]
-	call	convert_mmx_register
-	mov	[postbyte_register],al
-	call	make_mmx_prefix
-	mov	[extended_code],7Eh
 	call	operand_64bit
-	jmp	nomem_instruction_ready
+	call	get_mmx_source_register
+	jmp	nomem_instruction_ready
      movq_mmreg:
 	call	convert_mmx_register
 	mov	[postbyte_register],al
 	mov	[extended_code],6Fh
 	mov	[mmx_size],ah
 	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	je	movq_mmreg_reg
-	call	get_address
+	cmp	al,'['
+	jne	invalid_operand
+	call	get_address
 	test	[operand_size],not 8
 	jnz	invalid_operand_size
 	jmp	instruction_ready
       movq_mmreg_reg:
 	lods	byte [esi]
 	mov	[opcode_prefix],66h
 movmskps_instruction:
 	mov	[base_code],0Fh
 	mov	[extended_code],50h
-	lods	byte [esi]
+	call	take_register
-	call	get_size_operator
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	mov	[postbyte_register],al
 	cmp	ah,4
 	je	movmskps_reg_ok
 	cmp	ah,8
 	jne	invalid_operand_size
 	cmp	[code_type],64
 	mov	[mmx_size],8
       cvt2si_instruction:
 	mov	[extended_code],al
 	mov	[base_code],0Fh
-	lods	byte [esi]
+	call	take_register
-	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	instruction_assembled
 sse4_instruction_38_xmm0:
 	mov	[immediate_size],-1
+	jmp	sse4_instruction_38
+sse4_instruction_66_38_xmm0:
+	mov	[immediate_size],-1
+sse4_instruction_66_38:
+	mov	[opcode_prefix],66h
 sse4_instruction_38:
 	mov	[mmx_size],16
-	mov	[opcode_prefix],66h
 	mov	[supplemental_code],al
 	mov	al,38h
 	jmp	sse_instruction
-sse4_ss_instruction_3a_imm8:
+sse4_ss_instruction_66_3a_imm8:
 	mov	[immediate_size],1
-	mov	[mmx_size],4
+	mov	cl,4
-	jmp	sse4_instruction_3a_setup
+	jmp	sse4_instruction_66_3a_setup
-sse4_sd_instruction_3a_imm8:
+sse4_sd_instruction_66_3a_imm8:
 	mov	[immediate_size],1
-	mov	[mmx_size],8
+	mov	cl,8
-	jmp	sse4_instruction_3a_setup
+	jmp	sse4_instruction_66_3a_setup
-sse4_instruction_3a_imm8:
+sse4_instruction_66_3a_imm8:
 	mov	[immediate_size],1
-	mov	[mmx_size],16
+	mov	cl,16
-      sse4_instruction_3a_setup:
+      sse4_instruction_66_3a_setup:
 	mov	[opcode_prefix],66h
+      sse4_instruction_3a_setup:
 	mov	[supplemental_code],al
 	mov	al,3Ah
+	mov	[mmx_size],cl
 	jmp	sse_instruction
+sse4_instruction_3a_imm8:
+	mov	[immediate_size],1
+	mov	cl,16
+	jmp	sse4_instruction_3a_setup
 pclmulqdq_instruction:
 	mov	byte [value],al
-	mov	[mmx_size],16
 	mov	al,44h
+	mov	cl,16
-	jmp	sse4_instruction_3a_setup
+	jmp	sse4_instruction_66_3a_setup
 extractps_instruction:
-	mov	[opcode_prefix],66h
-	mov	[base_code],0Fh
-	mov	[extended_code],3Ah
+	call	setup_66_0f_3a
-	mov	[supplemental_code],17h
 	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	je	extractps_reg
 	cmp	al,'['
 	cmp	al,4
 	je	mmx_nomem_imm8
 	cmp	al,8
 	jne	invalid_operand_size
-	call	operand_64bit
+	cmp	[code_type],64
-	jmp	mmx_nomem_imm8
+	jne	illegal_instruction
+	jmp	mmx_nomem_imm8
-insertps_instruction:
+      setup_66_0f_3a:
+	mov	[extended_code],3Ah
+	mov	[supplemental_code],al
+	mov	[base_code],0Fh
+	mov	[opcode_prefix],66h
+	ret
+insertps_instruction:
-	lods	byte [esi]
+	call	setup_66_0f_3a
+	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	jne	invalid_operand
 	lods	byte [esi]
 	call	convert_xmm_register
 	mov	[postbyte_register],al
-      insertps_xmmreg:
+	mov	[operand_size],0
-	mov	[opcode_prefix],66h
-	mov	[base_code],0Fh
-	mov	[extended_code],3Ah
-	mov	[supplemental_code],21h
-	mov	[operand_size],0
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
 	lods	byte [esi]
 	call	get_size_operator
 	jmp	pextr_instruction
 pextrb_instruction:
 	mov	[mmx_size],1
       pextr_instruction:
-	mov	[opcode_prefix],66h
+	call	setup_66_0f_3a
-	mov	[base_code],0Fh
-	mov	[extended_code],3Ah
-	mov	[supplemental_code],al
+	lods	byte [esi]
-	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	je	pextr_reg
 	cmp	al,'['
 	jne	invalid_operand
       pextr_reg_store:
 	cmp	bh,16
 	jne	invalid_operand_size
 	xchg	bl,[postbyte_register]
-	call	operand_autodetect
+	jmp	mmx_nomem_imm8
-	jmp	mmx_nomem_imm8
 pinsrb_instruction:
 	mov	[mmx_size],1
 	jmp	pinsr_instruction
 pinsrd_instruction:
 	mov	[mmx_size],4
 pinsrq_instruction:
 	mov	[mmx_size],8
 	call	operand_64bit
       pinsr_instruction:
-	mov	[opcode_prefix],66h
+	call	setup_66_0f_3a
-	mov	[base_code],0Fh
-	mov	[extended_code],3Ah
-	mov	[supplemental_code],al
+	lods	byte [esi]
-	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	jne	invalid_operand
 	lods	byte [esi]
 	call	convert_xmm_register
 	jmp	pmovsx_instruction
 pmovsxdq_instruction:
 	mov	[mmx_size],8
       pmovsx_instruction:
-	mov	[opcode_prefix],66h
+	call	setup_66_0f_38
-	mov	[base_code],0Fh
-	mov	[extended_code],38h
-	mov	[supplemental_code],al
+	lods	byte [esi]
-	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	jne	invalid_operand
 	lods	byte [esi]
 	call	convert_xmm_register
 	lods	byte [esi]
 	call	convert_xmm_register
 	mov	bl,al
 	jmp	nomem_instruction_ready
       setup_66_0f_38:
+	mov	[extended_code],38h
+	mov	[supplemental_code],al
+	mov	[base_code],0Fh
+	mov	[opcode_prefix],66h
+	ret
 fxsave_instruction_64bit:
 	call	operand_64bit
 fxsave_instruction:
 	mov	[extended_code],0AEh
 	jmp	instruction_ready
 amd_prefetch_instruction:
 	mov	[extended_code],0Dh
 	jmp	prefetch_mem_8bit
-fence_instruction:
+clflushopt_instruction:
+	mov	[extended_code],0AEh
+	mov	[opcode_prefix],66h
+	jmp	prefetch_mem_8bit
+pcommit_instruction:
+	mov	byte [edi],66h
+	inc	edi
+fence_instruction:
 	mov	bl,al
 	mov	ax,0AE0Fh
 	stos	word [edi]
 	mov	al,bl
 	stos	byte [edi]
 	call	get_address
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	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:
 	cmp	byte [esi],0
 	je	monitor_instruction_store
 	cmp	byte [esi],0Fh
 	je	monitor_instruction_store
-	lods	byte [esi]
+	call	take_register
-	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	take_register
-	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	take_register
-	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
 movntdqa_instruction:
-	mov	[opcode_prefix],66h
+	call	setup_66_0f_38
-	mov	[base_code],0Fh
-	mov	[extended_code],38h
-	mov	[supplemental_code],al
+	lods	byte [esi]
-	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
 	jne	invalid_operand
 	lods	byte [esi]
 	call	convert_xmm_register
 	mov	[opcode_prefix],0F2h
 	mov	[base_code],0Fh
 	mov	[extended_code],38h
 	mov	[supplemental_code],0F0h
-	lods	byte [esi]
+	call	take_register
-	call	get_size_operator
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	mov	[postbyte_register],al
-	cmp	ah,8
+	cmp	ah,4
-	je	crc32_reg64
-	cmp	ah,4
-	jne	invalid_operand
+	je	crc32_reg_size_ok
+	cmp	ah,8
+	jne	invalid_operand
-	lods	byte [esi]
+	cmp	[code_type],64
+	jne	illegal_instruction
+      crc32_reg_size_ok:
+	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
 	mov	[operand_size],0
 	lods	byte [esi]
 	call	get_size_operator
 	cmp	al,10h
-	je	crc32_reg32_reg
+	je	crc32_reg_reg
 	cmp	al,'['
 	jne	invalid_operand
 	call	get_address
 	mov	al,[operand_size]
 	test	al,al
 	jz	crc32_unknown_size
 	cmp	al,1
-	je	crc32_reg32_mem_store
+	je	crc32_reg_mem_store
-	cmp	al,4
+	inc	[supplemental_code]
-	ja	invalid_operand_size
-	inc	[supplemental_code]
 	call	operand_autodetect
-      crc32_reg32_mem_store:
+      crc32_reg_mem_store:
 	jmp	instruction_ready
       crc32_unknown_size:
 	call	recoverable_unknown_size
-	jmp	crc32_reg32_mem_store
+	jmp	crc32_reg_mem_store
-      crc32_reg32_reg:
+      crc32_reg_reg:
 	lods	byte [esi]
 	call	convert_register
 	mov	bl,al
 	mov	al,ah
 	cmp	al,1
-	je	crc32_reg32_reg_store
+	je	crc32_reg_reg_store
-	cmp	al,4
+	inc	[supplemental_code]
-	ja	invalid_operand_size
-	inc	[supplemental_code]
 	call	operand_autodetect
-      crc32_reg32_reg_store:
+      crc32_reg_reg_store:
 	jmp	nomem_instruction_ready
-      crc32_reg64:
+popcnt_instruction:
-	lods	byte [esi]
-	cmp	al,','
-	jne	invalid_operand
-	mov	[operand_size],0
-	call	operand_64bit
-	lods	byte [esi]
-	call	get_size_operator
-	cmp	al,10h
-	je	crc32_reg64_reg
-	cmp	al,'['
-	jne	invalid_operand
-	call	get_address
-	mov	ah,[operand_size]
-	mov	al,8
-	test	ah,ah
-	jz	crc32_unknown_size
-	cmp	ah,1
-	je	crc32_reg32_mem_store
-	cmp	ah,al
-	jne	invalid_operand_size
-	inc	[supplemental_code]
-	jmp	crc32_reg32_mem_store
-      crc32_reg64_reg:
-	lods	byte [esi]
-	call	convert_register
-	mov	bl,al
-	mov	al,8
-	cmp	ah,1
-	je	crc32_reg32_reg_store
-	cmp	ah,al
-	jne	invalid_operand_size
-	inc	[supplemental_code]
-	jmp	crc32_reg32_reg_store
-popcnt_instruction:
 	mov	[opcode_prefix],0F3h
 	jmp	bs_instruction
 movbe_instruction:
 	mov	[supplemental_code],al
 	mov	[extended_code],38h
 	push	edx ebx ecx
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	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,[operand_size]
 	call	operand_autodetect
 	jmp	instruction_ready
 adx_instruction:
 	jne	invalid_operand_size
 	call	operand_64bit
 	jmp	nomem_instruction_ready
-simple_vmx_instruction:
-	mov	ah,al
-	mov	al,0Fh
-	stos	byte [edi]
-	mov	al,1
-	stos	word [edi]
-	jmp	instruction_assembled
 vmclear_instruction:
 	mov	[opcode_prefix],66h
 	jmp	vmx_instruction
 vmxon_instruction:
 	mov	[opcode_prefix],0F3h
 	call	get_address
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	call	get_size_operator
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	mov	[postbyte_register],al
 	call	vmread_check_size
 	jmp	vmx_size_ok
       vmread_nomem:
 	lods	byte [esi]
 	call	convert_register
 	call	vmread_check_size
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
-	lods	byte [esi]
+	call	take_register
-	call	get_size_operator
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	mov	[postbyte_register],al
 	call	vmread_check_size
 	pop	ebx
 	mov	[base_code],0Fh
 	jmp	nomem_instruction_ready
       vmread_check_size:
 	jne	invalid_operand_size
 	ret
 vmwrite_instruction:
 	mov	[extended_code],79h
-	lods	byte [esi]
+	call	take_register
-	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
 	mov	bl,al
 	mov	[base_code],0Fh
 	jmp	nomem_instruction_ready
 vmx_inv_instruction:
-	mov	[opcode_prefix],66h
+	call	setup_66_0f_38
-	mov	[extended_code],38h
-	mov	[supplemental_code],al
-	lods	byte [esi]
-	call	get_size_operator
-	cmp	al,10h
+	call	take_register
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	mov	[postbyte_register],al
 	call	vmread_check_size
 	mov	[operand_size],0
 	lods	byte [esi]
 	cmp	al,','
 	jne	invalid_operand
 simple_svm_instruction:
 	push	eax
 	mov	[base_code],0Fh
 	mov	[extended_code],1
-	lods	byte [esi]
+	call	take_register
-	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
       prefixed_svm_store:
 	mov	al,67h
 	stos	byte [edi]
       simple_svm_store:
-	call	store_instruction_code
+	call	store_classic_instruction_code
 	pop	eax
 	stos	byte [edi]
 	jmp	instruction_assembled
 skinit_instruction:
-	lods	byte [esi]
+	call	take_register
-	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
+	jmp	simple_instruction_0f_01
 invlpga_instruction:
 	push	eax
 	mov	[base_code],0Fh
 	mov	[extended_code],1
-	lods	byte [esi]
+	call	take_register
-	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	take_register
-	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
 rdrand_instruction:
 	mov	[base_code],0Fh
 	mov	[extended_code],0C7h
 	mov	[postbyte_register],al
-	lods	byte [esi]
-	call	get_size_operator
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
+	call	take_register
 	mov	bl,al
 	mov	al,ah
 	call	operand_autodetect
 	jmp	nomem_instruction_ready
 rdfsbase_instruction:
 	mov	[opcode_prefix],0F3h
 	mov	[base_code],0Fh
 	mov	[extended_code],0AEh
 	mov	[postbyte_register],al
-	lods	byte [esi]
+	call	take_register
-	call	get_size_operator
-	cmp	al,10h
-	jne	invalid_operand
-	lods	byte [esi]
-	call	convert_register
 	mov	bl,al
 	mov	al,ah
 	cmp	ah,2
 	je	invalid_operand_size
 	call	operand_autodetect
 	jmp	nomem_instruction_ready
       xbegin_rel32:
 	sub	edx,1
 	jno	xbegin_rel32_ok
 	cmp	[code_type],64
-	je	relative_jump_out_of_range
+	je	jump_out_of_range
       xbegin_rel32_ok:
 	mov	ax,0F8C7h
 	stos	word [edi]
 	mov	eax,edx
 	stos	dword [edi]
 	jmp	instruction_assembled
+bndcl_instruction:
+	mov	ah,0F3h
+	jmp	bndc_instruction
+bndcu_instruction:
+	mov	ah,0F2h
+      bndc_instruction:
+	mov	[opcode_prefix],ah
+	mov	[base_code],0Fh
+	mov	[extended_code],al
+	call	take_bnd_register
+	mov	[postbyte_register],al
+	call	get_bnd_size
+	mov	[operand_size],al
+	lods	byte [esi]
+	cmp	al,','
+	jne	invalid_operand
+	lods	byte [esi]
+	call	get_size_operator
+	cmp	al,'['
+	je	bndc_mem
+	cmp	al,10h
+	jne	invalid_operand
+	lods	byte [esi]
+	call	convert_register
+	mov	bl,al
+	jmp	nomem_instruction_ready
+      bndc_mem:
+	call	get_address_of_required_size
+	jmp	instruction_ready
+bndmov_instruction:
+	mov	[opcode_prefix],66h
+	mov	[base_code],0Fh
+	mov	[extended_code],al
+	call	get_bnd_size
+	shl	al,1
+	mov	[operand_size],al
+	lods	byte [esi]
+	cmp	al,14h
+	je	bndmov_reg
+	call	get_size_operator
+	cmp	al,'['
+	jne	invalid_operand
+	inc	[extended_code]
+	call	get_address_of_required_size
+	lods	byte [esi]
+	cmp	al,','
+	jne	invalid_operand
+	call	take_bnd_register
+	mov	[postbyte_register],al
+	jmp	instruction_ready
+       bndmov_reg:
+	lods	byte [esi]
+	call	convert_bnd_register
+	mov	[postbyte_register],al
+	lods	byte [esi]
+	cmp	al,','
+	jne	invalid_operand
+	lods	byte [esi]
+	cmp	al,14h
+	je	bndmov_reg_reg
+	call	get_size_operator
+	cmp	al,'['
+	jne	invalid_operand
+	call	get_address_of_required_size
+	jmp	instruction_ready
+      bndmov_reg_reg:
+	lods	byte [esi]
+	call	convert_bnd_register
+	mov	bl,al
+	jmp	nomem_instruction_ready
+    take_bnd_register:
+	lods	byte [esi]
+	cmp	al,14h
+	jne	invalid_operand
+	lods	byte [esi]
+    convert_bnd_register:
+	mov	ah,al
+	shr	ah,4
+	cmp	ah,6
+	jne	invalid_operand
+	and	al,1111b
+	ret
+bndmk_instruction:
+	mov	[opcode_prefix],0F3h
+	mov	[base_code],0Fh
+	mov	[extended_code],al
+	call	take_bnd_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_bnd_size
+	call	get_address_prefixes
+	call	get_address_component
+	cmp	byte [esi-1],']'
+	je	bndmk_ready
+	lods	byte [esi]
+	cmp	al,','
+	jne	invalid_operand
+	lods	byte [esi]
+	cmp	al,'('
+	jne	invalid_operand
+	or	dl,bl
+	or	dl,[address_sign]
+	or	edx,[address_high]
+	jnz	invalid_address
+	mov	[address_register],bh
+	call	get_address_component
+	lods	byte [esi]
+	cmp	al,']'
+	jne	invalid_operand
+	or	bh,bh
+	jz	bndmk_selected_base
+	cmp	bl,bh
+	je	bndmk_to_index
+	or	bl,bl
+	jnz	invalid_address
+	mov	bl,bh
+      bndmk_to_index:
+	inc	cl
+      bndmk_selected_base:
+	mov	bh,[address_register]
+      bndmk_ready:
+	or	bx,bx
+	jz	instruction_ready
+	cmp	[address_size_declared],0
+	jne	instruction_ready
+	and	ch,not 0Fh
+	jmp	instruction_ready
+    get_bnd_size:
+	mov	al,4
+	cmp	[code_type],64
+	jne	bnd_size_ok
+	add	al,4
+      bnd_size_ok:
+	mov	[address_size],al
+	ret
+    get_address_component:
+	mov	[free_address_range],0
+	call	calculate_address
+	mov	[address_high],edx
+	mov	edx,eax
+	or	bx,bx
+	jz	address_component_ok
+	mov	al,bl
+	or	al,bh
+	shr	al,4
+	cmp	al,[address_size]
+	jne	invalid_address
+      address_component_ok:
+	ret
+bndldx_instruction:
+	mov	[base_code],0Fh
+	mov	[extended_code],al
+	call	take_bnd_register
+	mov	[postbyte_register],al
+	lods	byte [esi]
+	cmp	al,','
+	jne	invalid_operand
+	call	take_bnd_mib
+	jmp	bndmk_ready
+bndstx_instruction:
+	mov	[base_code],0Fh
+	mov	[extended_code],al
+	call	take_bnd_mib
+	lods	byte [esi]
+	cmp	al,','
+	jne	invalid_operand
+	call	take_bnd_register
+	mov	[postbyte_register],al
+	jmp	bndmk_ready
+    take_bnd_mib:
+	lods	byte [esi]
+	cmp	al,'['
+	jne	invalid_operand
+	call	get_bnd_size
+	call	get_address_prefixes
+	call	get_address_component
+	cmp	byte [esi-1],']'
+	je	bnd_mib_ok
+	lods	byte [esi]
+	cmp	al,','
+	jne	invalid_operand
+	lods	byte [esi]
+	cmp	al,'('
+	jne	invalid_operand
+	mov	al,[address_sign]
+	push	eax ebx ecx edx [address_symbol]
+	call	get_address_component
+	lods	byte [esi]
+	cmp	al,']'
+	jne	invalid_operand
+	or	dl,bl
+	or	dl,[address_sign]
+	or	edx,[address_high]
+	jnz	invalid_address
+	mov	[address_register],bh
+	pop	[address_symbol] edx ecx ebx eax
+	mov	[address_sign],al
+	or	bl,bl
+	jz	mib_place_index
+	or	bh,bh
+	jnz	invalid_address
+	cmp	cl,1
+	jne	invalid_address
+	mov	bh,bl
+      mib_place_index:
+	mov	bl,[address_register]
+	xor	cl,cl
+	or	al,al
+	jz	bnd_mib_ok
+	inc	cl
+      bnd_mib_ok:
+	ret
+take_register:
+	lods	byte [esi]
+	call	get_size_operator
+	cmp	al,10h
+	jne	invalid_operand
+	lods	byte [esi]
 convert_register:
 	mov	ah,al
 	shr	ah,4
 	and	al,0Fh
 	cmp	ah,8
       register_size_ok:
 	ret
       high_byte_register:
 	mov	ah,1
-	or	[rex_prefix],80h
+	or	[rex_prefix],10h
 	jmp	match_register_size
 convert_fpu_register:
 	mov	ah,al
 	shr	ah,4
 	and	al,111b
 	cmp	ah,10
 	and	al,111b
 	cmp	ah,0Bh
 	jne	invalid_operand
 	mov	ah,8
-	cmp	[vex_required],0
+	jmp	match_register_size
-	jne	invalid_operand
-	jmp	match_register_size
       xmm_register:
 	and	al,0Fh
 	mov	ah,16
 	cmp	al,8
 	jb	match_register_size
 	jne	no_size_operator
 	mov	[size_declared],1
 	lods	word [esi]
 	xchg	al,ah
-	mov	[size_override],1
+	or	[operand_flags],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:
       no_size_operator:
 	mov	[size_declared],0
 	cmp	al,'['
 	jne	size_operator_ok
-	mov	[size_override],0
+	and	[operand_flags],not 1
 	ret
 get_jump_operator:
 	mov	[jump_type],0
 	cmp	al,12h
 	jne	jump_operator_ok
 	lods	word [esi]
 	mov	al,ah
       jump_operator_ok:
 	ret
 get_address:
-	mov	[segment_register],0
+	and	[address_size],0
-	mov	[address_size],0
-	mov	[free_address_range],0
+    get_address_of_required_size:
-	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]
+	call	get_address_prefixes
-	sub	al,70h
-	cmp	al,2
-	jb	invalid_address_size
-	cmp	al,8
-	ja	invalid_address_size
-	mov	[address_size],al
+	and	[free_address_range],0
-	mov	[value_size],al
+	call	calculate_address
-      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
+	cmp	[address_size_declared],0
 	jne	address_ok
 	or	bx,bx
-	jnz	address_ok
+	jnz	clear_address_size
-	test	ch,0Fh
+	cmp	[code_type],64
-	jnz	address_ok
+	jne	address_ok
       calculate_relative_address:
 	mov	edx,[address_symbol]
 	mov	[symbol_identifier],edx
 	mov	edx,[address_high]
 	mov	ebp,[addressing_space]
 	call	calculate_relative_offset
 	mov	edx,eax
 	ror	ecx,16
 	mov	cl,[value_type]
 	rol	ecx,16
-	mov	bx,0FF00h
+	mov	bx,9900h
-      address_ok:
+      clear_address_size:
+	and	ch,not 0Fh
+      address_ok:
 	ret
-operand_16bit:
+get_address_prefixes:
+	and	[segment_register],0
+	and	[address_size_declared],0
+	mov	al,[code_type]
+	shr	al,3
+	mov	[value_size],al
+	mov	al,[esi]
+	and	al,11110000b
+	cmp	al,60h
+	jne	get_address_size_prefix
+	lods	byte [esi]
+	sub	al,60h
+	mov	[segment_register],al
+	mov	al,[esi]
+	and	al,11110000b
+      get_address_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	[value_size],al
+	or	[address_size_declared],1
+	or	[address_size],al
+	cmp	al,[address_size]
+	jne	invalid_address_size
+      address_size_prefix_ok:
+	ret
+operand_16bit:
 	cmp	[code_type],16
 	je	size_prefix_ok
 	mov	[operand_prefix],66h
 	ret
 operand_32bit:
 	ret
 store_instruction_code:
 	cmp	[vex_required],0
 	jne	store_vex_instruction_code
-	mov	al,[operand_prefix]
+store_classic_instruction_code:
+	mov	al,[operand_prefix]
 	or	al,al
 	jz	operand_prefix_ok
 	stos	byte [edi]
       operand_prefix_ok:
 	mov	al,[opcode_prefix]
 	mov	al,[supplemental_code]
 	stos	byte [edi]
 	ret
 store_nomem_instruction:
-	test	[postbyte_register],1000b
+	test	[postbyte_register],10000b
+	jz	nomem_reg_high_code_ok
+	or	[vex_required],10h
+	and	[postbyte_register],1111b
+      nomem_reg_high_code_ok:
+	test	[postbyte_register],1000b
 	jz	nomem_reg_code_ok
 	or	[rex_prefix],44h
 	and	[postbyte_register],111b
       nomem_reg_code_ok:
-	test	bl,1000b
+	test	bl,10000b
+	jz	nomem_rm_high_code_ok
+	or	[rex_prefix],42h
+	or	[vex_required],8
+	and	bl,1111b
+      nomem_rm_high_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
+	and	[displacement_compression],0
+	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
+	and	[displacement_compression],0
+	test	[postbyte_register],10000b
+	jz	reg_high_code_ok
+	or	[vex_required],10h
+	and	[postbyte_register],1111b
+      reg_high_code_ok:
+	test	[postbyte_register],1000b
 	jz	reg_code_ok
 	or	[rex_prefix],44h
 	and	[postbyte_register],111b
       reg_code_ok:
 	cmp	[code_type],64
 	test	[vex_required],4
 	jnz	address_vsib
 	or	bx,bx
 	jz	address_immediate
-	cmp	bx,0F800h
+	cmp	bx,9800h
 	je	address_rip_based
-	cmp	bx,0F400h
+	cmp	bx,9400h
 	je	address_eip_based
-	cmp	bx,0FF00h
+	cmp	bx,9900h
 	je	address_relative
 	mov	al,bl
 	or	al,bh
 	and	al,11110000b
 	cmp	al,80h
 	je	postbyte_64bit
 	jne	invalid_address
 	cmp	[code_type],64
 	je	invalid_address_size
 	call	address_16bit_prefix
-	call	store_instruction_code
+	test	ch,22h
+	setz	[displacement_compression]
+	call	store_instruction_code
 	cmp	bl,bh
 	jbe	determine_16bit_address
 	xchg	bl,bh
       determine_16bit_address:
 	cmp	bx,2600h
 	cmp	edx,-8000h
 	jl	value_out_of_range
 	or	dx,dx
 	jz	address
-	cmp	dx,80h
+	cmp	[displacement_compression],2
+	ja	address_8bit_value
+	je	address_16bit_value
+	cmp	dx,80h
 	jb	address_8bit_value
 	cmp	dx,-80h
 	jae	address_8bit_value
       address_16bit_value:
 	or	al,10000000b
 	or	al,cl
 	stos	byte [edi]
 	mov	al,dl
 	stos	byte [edi]
-	cmp	dx,80h
+	ret
-	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
 	ret
       address_vsib:
 	mov	al,bl
 	shr	al,4
-	cmp	al,0Ch
+	test	al,1
+	jz	vsib_high_code_ok
+	or	[vex_register],10000b
+	or	[vex_required],8
+	xor	al,1
+      vsib_high_code_ok:
+	cmp	al,6
+	je	vsib_index_ok
+	cmp	al,0Ch
-	je	vector_index_ok
+	jb	invalid_address
-	cmp	al,0Dh
-	jne	invalid_address
-      vector_index_ok:
+      vsib_index_ok:
 	mov	al,bh
 	shr	al,4
 	cmp	al,4
 	je	postbyte_32bit
 	cmp	[code_type],64
 	je	address_prefix_ok
 	test	bl,1000b
 	jz	index_code_ok
 	or	[rex_prefix],42h
       index_code_ok:
-	call	store_instruction_code
+	test	ch,44h or 88h
+	setz	[displacement_compression]
+	call	store_instruction_code
 	or	cl,cl
 	jz	only_base_register
       base_and_index:
 	mov	al,100b
 	xor	ah,ah
 	or	ah,bl
 	and	bh,111b
 	or	ah,bh
       sib_ready:
-	test	ch,44h
+	test	ch,44h or 88h
-	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
+	cmp	[displacement_compression],2
+	ja	sib_address_8bit_value
+	je	sib_address_32bit_value
+	cmp	edx,80h
 	jb	sib_address_8bit_value
 	cmp	edx,-80h
-	jae	sib_address_8bit_value
+	jnb	sib_address_8bit_value
       sib_address_32bit_value:
 	or	al,10000000b
 	mov	cl,[postbyte_register]
 	shl	cl,3
 	or	al,cl
 	stos	word [edi]
 	or	al,cl
 	stos	word [edi]
 	mov	al,dl
 	stos	byte [edi]
-	cmp	edx,80h
+	ret
-	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]
 	mov	cl,[postbyte_register]
 	shl	cl,3
 	or	al,cl
 	stos	word [edi]
-	test	ch,44h
+	test	ch,44h or 88h
-	jnz	store_address_32bit_value
-	test	ch,88h
 	jnz	store_address_32bit_value
 	or	ch,ch
 	jnz	invalid_address_size
-	jmp	store_address_32bit_value
+	cmp	[displacement_compression],2
+	jbe	store_address_32bit_value
+	mov	edx,[uncompressed_displacement]
+	jmp	store_address_32bit_value
       zero_index_register:
 	mov	bl,4
 	mov	cl,1
 	jmp	base_and_index
       only_base_register:
 	mov	al,bh
 	and	al,111b
 	cmp	al,4
 	je	zero_index_register
-	test	ch,44h
+	test	ch,44h or 88h
-	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
+	cmp	[displacement_compression],2
+	ja	simple_address_8bit_value
+	je	simple_address_32bit_value
+	cmp	edx,80h
 	jb	simple_address_8bit_value
 	cmp	edx,-80h
-	jae	simple_address_8bit_value
+	jnb	simple_address_8bit_value
       simple_address_32bit_value:
 	or	al,10000000b
 	mov	cl,[postbyte_register]
 	shl	cl,3
 	or	al,cl
 	stos	byte [edi]
 	or	al,cl
 	stos	byte [edi]
 	mov	al,dl
 	stos	byte [edi]
-	cmp	edx,80h
+	ret
-	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
 	ret
       address_immediate:
 	cmp	[code_type],64
 	je	address_immediate_sib
-	test	ch,44h
+	test	ch,44h or 88h
-	jnz	address_immediate_32bit
-	test	ch,88h
 	jnz	address_immediate_32bit
 	test	ch,22h
 	jnz	address_immediate_16bit
 	or	ch,ch
 	jnz	invalid_address_size
 	cmp	[code_type],16
 	add	eax,edi
 	sub	eax,[current_offset]
 	add	eax,5
 	sub	edx,eax
-	jo	value_out_of_range
+	jno	@f
+	call	recoverable_overflow
-	mov	al,101b
+      @@:
+	mov	al,101b
 	mov	cl,[postbyte_register]
 	shl	cl,3
 	or	al,cl
 	stos	byte [edi]
 	shr	ecx,16

Subversion Repositories Kolibri OS

(root)/programs/develop/fasm/trunk/x86_64.inc – Rev 4039 → 6467