WebSVN – Kolibri OS – Blame – /programs/develop/fasm/trunk/avx.inc

Rev	Author	Line No.	Line
4039	heavyiron	1
		2	; Copyright (c) 1999-2013, Tomasz Grysztar.
		3	; All rights reserved.
		4
		5
		6	or [vex_required],2
		7	jmp avx_pd_instruction
		8	avx_pd_instruction_imm8:
		9	mov [immediate_size],1
		10	avx_pd_instruction:
		11	mov [opcode_prefix],66h
		12	mov [mmx_size],0
		13	jmp avx_instruction
		14	avx_single_source_ps_instruction:
		15	or [vex_required],2
		16	jmp avx_ps_instruction
		17	avx_ps_instruction_imm8:
		18	mov [immediate_size],1
		19	avx_ps_instruction:
		20	mov [mmx_size],0
		21	jmp avx_instruction
		22	avx_sd_instruction_imm8:
		23	mov [immediate_size],1
		24	avx_sd_instruction:
		25	mov [opcode_prefix],0F2h
		26	mov [mmx_size],8
		27	jmp avx_instruction
		28	avx_ss_instruction_imm8:
		29	mov [immediate_size],1
		30	avx_ss_instruction:
		31	mov [opcode_prefix],0F3h
		32	mov [mmx_size],4
		33	jmp avx_instruction
		34	avx_cmp_pd_instruction:
		35	mov [opcode_prefix],66h
		36	avx_cmp_ps_instruction:
		37	mov [mmx_size],0
		38	mov byte [value],al
		39	mov al,0C2h
		40	jmp avx_instruction
		41	avx_cmp_sd_instruction:
		42	mov [opcode_prefix],0F2h
		43	mov [mmx_size],8
		44	mov byte [value],al
		45	mov al,0C2h
		46	jmp avx_instruction
		47	avx_cmp_ss_instruction:
		48	mov [opcode_prefix],0F3h
		49	mov [mmx_size],4
		50	mov byte [value],al
		51	mov al,0C2h
		52	jmp avx_instruction
		53	avx_comiss_instruction:
		54	or [vex_required],2
		55	mov [mmx_size],4
		56	jmp avx_instruction
		57	avx_comisd_instruction:
		58	or [vex_required],2
		59	mov [opcode_prefix],66h
		60	mov [mmx_size],8
		61	jmp avx_instruction
		62	avx_haddps_instruction:
		63	mov [opcode_prefix],0F2h
		64	mov [mmx_size],0
		65	jmp avx_instruction
		66	avx_movshdup_instruction:
		67	or [vex_required],2
		68	mov [opcode_prefix],0F3h
		69	mov [mmx_size],0
		70	jmp avx_instruction
		71	avx_128bit_instruction:
		72	mov [mmx_size],16
		73	mov [opcode_prefix],66h
		74	avx_instruction:
		75	mov [base_code],0Fh
		76	mov [extended_code],al
		77	avx_common:
		78	or [vex_required],1
		79	lods byte [esi]
		80	call get_size_operator
		81	cmp al,10h
		82	jne invalid_operand
		83	avx_reg:
		84	lods byte [esi]
		85	call convert_avx_register
		86	mov [postbyte_register],al
		87	avx_vex_reg:
		88	test [vex_required],2
		89	jnz avx_vex_reg_ok
		90	lods byte [esi]
		91	cmp al,','
		92	jne invalid_operand
		93	call take_avx_register
		94	mov [vex_register],al
		95	avx_vex_reg_ok:
		96	cmp [mmx_size],0
		97	je avx_regs_size_ok
		98	cmp ah,16
		99	jne invalid_operand
		100	avx_regs_size_ok:
		101	lods byte [esi]
		102	cmp al,','
		103	jne invalid_operand
		104	call take_avx_rm
		105	jc avx_regs_reg
		106	mov al,[extended_code]
		107	mov ah,[supplemental_code]
		108	cmp al,0C2h
		109	je sse_cmp_mem_ok
		110	cmp ax,443Ah
		111	je sse_cmp_mem_ok
		112	mov al,[base_code]
		113	and al,11011100b
		114	cmp al,11001100b
		115	je sse_cmp_mem_ok
		116	cmp [immediate_size],1
		117	je mmx_imm8
		118	cmp [immediate_size],0
		119	jge instruction_ready
		120	cmp byte [esi],','
		121	jne invalid_operand
		122	inc esi
		123	call take_avx_register
		124	shl al,4
		125	or byte [value],al
		126	test al,80h
		127	jz avx_regs_mem_reg_store
		128	cmp [code_type],64
		129	jne invalid_operand
		130	avx_regs_mem_reg_store:
		131	call take_imm4_if_needed
		132	call store_instruction_with_imm8
		133	jmp instruction_assembled
		134	avx_regs_reg:
		135	mov bl,al
		136	mov al,[extended_code]
		137	mov ah,[supplemental_code]
		138	cmp al,0C2h
		139	je sse_cmp_nomem_ok
		140	cmp ax,443Ah
		141	je sse_cmp_nomem_ok
		142	mov al,[base_code]
		143	and al,11011100b
		144	cmp al,11001100b
		145	je sse_cmp_nomem_ok
		146	cmp [immediate_size],1
		147	je mmx_nomem_imm8
		148	cmp [immediate_size],0
		149	jge nomem_instruction_ready
		150	lods byte [esi]
		151	cmp al,','
		152	jne invalid_operand
		153	mov al,bl
		154	shl al,4
		155	or byte [value],al
		156	test al,80h
		157	jz avx_regs_reg_
		158	cmp [code_type],64
		159	jne invalid_operand
		160	avx_regs_reg_:
		161	call take_avx_rm
		162	jc avx_regs_reg_reg
		163	cmp [immediate_size],-2
		164	jg invalid_operand
		165	or [rex_prefix],8
		166	call take_imm4_if_needed
		167	call store_instruction_with_imm8
		168	jmp instruction_assembled
		169	avx_regs_reg_reg:
		170	shl al,4
		171	and byte [value],1111b
		172	or byte [value],al
		173	call take_imm4_if_needed
		174	call store_nomem_instruction
		175	mov al,byte [value]
		176	stos byte [edi]
		177	jmp instruction_assembled
		178	take_avx_rm:
		179	xor cl,cl
		180	xchg cl,[operand_size]
		181	lods byte [esi]
		182	call get_size_operator
		183	cmp al,'['
		184	je take_avx_mem
		185	mov [operand_size],cl
		186	cmp al,10h
		187	jne invalid_operand
		188	lods byte [esi]
		189	call convert_avx_register
		190	cmp [mmx_size],0
		191	je avx_reg_ok
		192	cmp ah,16
		193	jne invalid_operand
		194	avx_reg_ok:
		195	stc
		196	ret
		197	take_avx_mem:
		198	push ecx
		199	call get_address
		200	pop eax
		201	cmp [mmx_size],0
		202	jne avx_smem
		203	xchg al,[operand_size]
		204	or al,al
		205	jz avx_mem_ok
		206	cmp al,[operand_size]
		207	jne operand_sizes_do_not_match
		208	avx_mem_ok:
		209	clc
		210	ret
		211	avx_smem:
		212	xchg al,[operand_size]
		213	or al,al
		214	jz avx_smem_ok
		215	cmp al,[mmx_size]
		216	jne invalid_operand_size
		217	avx_smem_ok:
		218	clc
		219	ret
		220	take_imm4_if_needed:
		221	cmp [immediate_size],-3
		222	jne imm4_ok
		223	push ebx ecx edx
		224	lods byte [esi]
		225	cmp al,','
		226	jne invalid_operand
		227	lods byte [esi]
		228	cmp al,'('
		229	jne invalid_operand
		230	call get_byte_value
		231	test al,11110000b
		232	jnz value_out_of_range
		233	or byte [value],al
		234	pop edx ecx ebx
		235	imm4_ok:
		236	ret
		237
		238
		239	or [vex_required],2
		240	avx_128bit_instruction_38:
		241	mov [mmx_size],16
		242	jmp avx_instruction_38_setup
		243	avx_single_source_instruction_38:
		244	or [vex_required],2
		245	avx_instruction_38:
		246	mov [mmx_size],0
		247	avx_instruction_38_setup:
		248	mov [opcode_prefix],66h
		249	mov [supplemental_code],al
		250	mov al,38h
		251	jmp avx_instruction
		252	avx_instruction_38_w1:
		253	or [rex_prefix],8
		254	jmp avx_instruction_38
		255
		256
		257	mov [mmx_size],4
		258	jmp avx_instruction_3a_imm8_setup
		259	avx_sd_instruction_3a_imm8:
		260	mov [mmx_size],8
		261	jmp avx_instruction_3a_imm8_setup
		262	avx_single_source_128bit_instruction_3a_imm8:
		263	or [vex_required],2
		264	avx_128bit_instruction_3a_imm8:
		265	mov [mmx_size],16
		266	jmp avx_instruction_3a_imm8_setup
		267	avx_triple_source_instruction_3a:
		268	mov [mmx_size],0
		269	mov [immediate_size],-1
		270	mov byte [value],0
		271	jmp avx_instruction_3a_setup
		272	avx_single_source_instruction_3a_imm8:
		273	or [vex_required],2
		274	avx_instruction_3a_imm8:
		275	mov [mmx_size],0
		276	avx_instruction_3a_imm8_setup:
		277	mov [immediate_size],1
		278	avx_instruction_3a_setup:
		279	mov [opcode_prefix],66h
		280	mov [supplemental_code],al
		281	mov al,3Ah
		282	jmp avx_instruction
		283	avx_pclmulqdq_instruction:
		284	mov byte [value],al
		285	mov [mmx_size],16
		286	mov al,44h
		287	jmp avx_instruction_3a_setup
		288
		289
		290	or [vex_required],2
		291	or [rex_prefix],8
		292	avx_perm2f128_instruction:
		293	mov [immediate_size],1
		294	mov ah,3Ah
		295	jmp avx_perm_instruction
		296	avx_permd_instruction:
		297	mov ah,38h
		298	avx_perm_instruction:
		299	mov [opcode_prefix],66h
		300	mov [base_code],0Fh
		301	mov [extended_code],ah
		302	mov [supplemental_code],al
		303	mov [mmx_size],0
		304	or [vex_required],1
		305	call take_avx_register
		306	cmp ah,32
		307	jne invalid_operand_size
		308	mov [postbyte_register],al
		309	jmp avx_vex_reg
		310
		311
		312	mov [opcode_prefix],0F3h
		313	jmp avx_movps_instruction
		314	avx_movpd_instruction:
		315	mov [opcode_prefix],66h
		316	avx_movps_instruction:
		317	mov [mmx_size],0
		318	or [vex_required],2
		319	mov [base_code],0Fh
		320	mov [extended_code],al
		321	lods byte [esi]
		322	call get_size_operator
		323	cmp al,10h
		324	je avx_reg
		325	inc [extended_code]
		326	test [extended_code],1
		327	jnz avx_mem
		328	add [extended_code],-1+10h
		329	avx_mem:
		330	cmp al,'['
		331	jne invalid_operand
		332	call get_address
		333	lods byte [esi]
		334	cmp al,','
		335	jne invalid_operand
		336	call take_avx_register
		337	mov [postbyte_register],al
		338	jmp instruction_ready
		339	avx_movntpd_instruction:
		340	mov [opcode_prefix],66h
		341	avx_movntps_instruction:
		342	or [vex_required],1
		343	mov [base_code],0Fh
		344	mov [extended_code],al
		345	lods byte [esi]
		346	call get_size_operator
		347	jmp avx_mem
		348	avx_lddqu_instruction:
		349	mov [opcode_prefix],0F2h
		350	mov [mmx_size],0
		351	xor cx,cx
		352	avx_load_instruction:
		353	mov [base_code],0Fh
		354	mov [extended_code],al
		355	or [vex_required],1
		356	call take_avx_register
		357	or cl,cl
		358	jz avx_load_reg_ok
		359	cmp ah,cl
		360	jne invalid_operand
		361	avx_load_reg_ok:
		362	cmp [mmx_size],0
		363	je avx_load_reg_
		364	xor ah,ah
		365	avx_load_reg_:
		366	xchg ah,[operand_size]
		367	push eax
		368	lods byte [esi]
		369	cmp al,','
		370	jne invalid_operand
		371	lods byte [esi]
		372	call get_size_operator
		373	cmp al,10h
		374	je avx_load_reg_reg
		375	cmp al,'['
		376	jne invalid_operand
		377	call get_address
		378	pop eax
		379	xchg ah,[operand_size]
		380	mov [postbyte_register],al
		381	mov al,[mmx_size]
		382	or al,al
		383	jz instruction_ready
		384	or ah,ah
		385	jz instruction_ready
		386	cmp al,ah
		387	jne invalid_operand_size
		388	jmp instruction_ready
		389	avx_load_reg_reg:
		390	lods byte [esi]
		391	call convert_avx_register
		392	cmp ch,ah
		393	jne invalid_operand
		394	mov bl,al
		395	pop eax
		396	xchg ah,[operand_size]
		397	mov [postbyte_register],al
		398	jmp nomem_instruction_ready
		399
		400
		401	mov [mmx_size],0
		402	xor cx,cx
		403	jmp avx_load_instruction_38
		404	avx_broadcastss_instruction:
		405	mov [mmx_size],4
		406	xor cl,cl
		407	mov ch,16
		408	jmp avx_load_instruction_38
		409	avx_broadcastsd_instruction:
		410	mov [mmx_size],8
		411	mov cl,32
		412	mov ch,16
		413	jmp avx_load_instruction_38
		414	avx_pbroadcastb_instruction:
		415	mov [mmx_size],1
		416	jmp avx_pbroadcast_instruction
		417	avx_pbroadcastw_instruction:
		418	mov [mmx_size],2
		419	jmp avx_pbroadcast_instruction
		420	avx_pbroadcastd_instruction:
		421	mov [mmx_size],4
		422	jmp avx_pbroadcast_instruction
		423	avx_pbroadcastq_instruction:
		424	mov [mmx_size],8
		425	avx_pbroadcast_instruction:
		426	xor cl,cl
		427	mov ch,16
		428	jmp avx_load_instruction_38
		429	avx_broadcastf128_instruction:
		430	mov [mmx_size],16
		431	mov cl,32
		432	xor ch,ch
		433	avx_load_instruction_38:
		434	mov [opcode_prefix],66h
		435	mov [supplemental_code],al
		436	mov al,38h
		437	jmp avx_load_instruction
		438	avx_movlpd_instruction:
		439	mov [opcode_prefix],66h
		440	avx_movlps_instruction:
		441	mov [base_code],0Fh
		442	mov [extended_code],al
		443	mov [mmx_size],8
		444	or [vex_required],1
		445	lods byte [esi]
		446	call get_size_operator
		447	cmp al,10h
		448	jne avx_movlps_mem
		449	lods byte [esi]
		450	call convert_avx_register
		451	mov [postbyte_register],al
		452	lods byte [esi]
		453	cmp al,','
		454	jne invalid_operand
		455	call take_avx_register
		456	mov [vex_register],al
		457	cmp [operand_size],16
		458	jne invalid_operand
		459	mov [operand_size],0
		460	lods byte [esi]
		461	cmp al,','
		462	jne invalid_operand
		463	call take_avx_rm
		464	jc invalid_operand
		465	jmp instruction_ready
		466	avx_movlps_mem:
		467	cmp al,'['
		468	jne invalid_operand
		469	call get_address
		470	mov al,[operand_size]
		471	or al,al
		472	jz avx_movlps_mem_size_ok
		473	cmp al,[mmx_size]
		474	jne invalid_operand_size
		475	mov [operand_size],0
		476	avx_movlps_mem_size_ok:
		477	lods byte [esi]
		478	cmp al,','
		479	jne invalid_operand
		480	call take_avx_register
		481	cmp ah,16
		482	jne invalid_operand
		483	mov [postbyte_register],al
		484	inc [extended_code]
		485	jmp instruction_ready
		486	avx_movhlps_instruction:
		487	mov [base_code],0Fh
		488	mov [extended_code],al
		489	or [vex_required],1
		490	call take_avx_register
		491	cmp ah,16
		492	jne invalid_operand
		493	mov [postbyte_register],al
		494	lods byte [esi]
		495	cmp al,','
		496	jne invalid_operand
		497	call take_avx_register
		498	mov [vex_register],al
		499	lods byte [esi]
		500	cmp al,','
		501	jne invalid_operand
		502	call take_avx_register
		503	mov bl,al
		504	jmp nomem_instruction_ready
		505	avx_maskmov_w1_instruction:
		506	or [rex_prefix],8
		507	avx_maskmov_instruction:
		508	call setup_66_0f_38
		509	mov [mmx_size],0
		510	or [vex_required],1
		511	lods byte [esi]
		512	call get_size_operator
		513	cmp al,10h
		514	jne avx_maskmov_mem
		515	lods byte [esi]
		516	call convert_avx_register
		517	mov [postbyte_register],al
		518	lods byte [esi]
		519	cmp al,','
		520	jne invalid_operand
		521	call take_avx_register
		522	mov [vex_register],al
		523	lods byte [esi]
		524	cmp al,','
		525	jne invalid_operand
		526	call take_avx_rm
		527	jc invalid_operand
		528	jmp instruction_ready
		529	avx_maskmov_mem:
		530	cmp al,'['
		531	jne invalid_operand
		532	call get_address
		533	lods byte [esi]
		534	cmp al,','
		535	jne invalid_operand
		536	call take_avx_register
		537	mov [vex_register],al
		538	lods byte [esi]
		539	cmp al,','
		540	jne invalid_operand
		541	call take_avx_register
		542	mov [postbyte_register],al
		543	add [supplemental_code],2
		544	jmp instruction_ready
		545	setup_66_0f_38:
		546	mov [extended_code],38h
		547	mov [supplemental_code],al
		548	mov [base_code],0Fh
		549	mov [opcode_prefix],66h
		550	ret
		551	avx_movd_instruction:
		552	or [vex_required],1
		553	jmp movd_instruction
		554	avx_movq_instruction:
		555	or [vex_required],1
		556	jmp movq_instruction
		557	avx_movddup_instruction:
		558	or [vex_required],1
		559	mov [opcode_prefix],0F2h
		560	mov [base_code],0Fh
		561	mov [extended_code],al
		562	lods byte [esi]
		563	call get_size_operator
		564	cmp al,10h
		565	jne invalid_operand
		566	lods byte [esi]
		567	call convert_avx_register
		568	mov [postbyte_register],al
		569	mov [mmx_size],0
		570	cmp ah,32
		571	je avx_regs_size_ok
		572	mov [mmx_size],8
		573	jmp avx_regs_size_ok
		574	avx_movmskpd_instruction:
		575	mov [opcode_prefix],66h
		576	avx_movmskps_instruction:
		577	mov [base_code],0Fh
		578	mov [extended_code],50h
		579	or [vex_required],1
		580	lods byte [esi]
		581	call get_size_operator
		582	cmp al,10h
		583	jne invalid_operand
		584	lods byte [esi]
		585	call convert_register
		586	mov [postbyte_register],al
		587	cmp ah,4
		588	je avx_movmskps_reg_ok
		589	cmp ah,8
		590	jne invalid_operand_size
		591	cmp [code_type],64
		592	jne invalid_operand
		593	avx_movmskps_reg_ok:
		594	mov [operand_size],0
		595	lods byte [esi]
		596	cmp al,','
		597	jne invalid_operand
		598	call take_avx_register
		599	mov bl,al
		600	jmp nomem_instruction_ready
		601	avx_movsd_instruction:
		602	mov [opcode_prefix],0F2h
		603	mov [mmx_size],8
		604	jmp avx_movs_instruction
		605	avx_movss_instruction:
		606	mov [opcode_prefix],0F3h
		607	mov [mmx_size],4
		608	avx_movs_instruction:
		609	or [vex_required],1
		610	mov [base_code],0Fh
		611	mov [extended_code],10h
		612	lods byte [esi]
		613	call get_size_operator
		614	cmp al,10h
		615	jne avx_movlps_mem
		616	lods byte [esi]
		617	call convert_xmm_register
		618	mov [postbyte_register],al
		619	xor cl,cl
		620	xchg cl,[operand_size]
		621	lods byte [esi]
		622	cmp al,','
		623	jne invalid_operand
		624	lods byte [esi]
		625	call get_size_operator
		626	cmp al,10h
		627	jne avx_movs_reg_mem
		628	mov [operand_size],cl
		629	lods byte [esi]
		630	call convert_avx_register
		631	mov [vex_register],al
		632	lods byte [esi]
		633	cmp al,','
		634	jne invalid_operand
		635	call take_avx_register
		636	mov bl,al
		637	cmp bl,8
		638	jb nomem_instruction_ready
		639	inc [extended_code]
		640	xchg bl,[postbyte_register]
		641	jmp nomem_instruction_ready
		642	avx_movs_reg_mem:
		643	cmp al,'['
		644	jne invalid_operand
		645	call get_address
		646	mov al,[operand_size]
		647	or al,al
		648	jz avx_movs_reg_mem_ok
		649	cmp al,[mmx_size]
		650	jne invalid_operand_size
		651	avx_movs_reg_mem_ok:
		652	jmp instruction_ready
		653
		654
		655	mov [opcode_prefix],0F3h
		656	avx_cvtps2pd_instruction:
		657	mov [base_code],0Fh
		658	mov [extended_code],al
		659	or [vex_required],1
		660	call take_avx_register
		661	mov [postbyte_register],al
		662	lods byte [esi]
		663	cmp al,','
		664	jne invalid_operand
		665	xor cl,cl
		666	xchg cl,[operand_size]
		667	lods byte [esi]
		668	call get_size_operator
		669	cmp al,10h
		670	jne avx_cvtdq2pd_reg_mem
		671	lods byte [esi]
		672	call convert_xmm_register
		673	mov bl,al
		674	mov [operand_size],cl
		675	jmp nomem_instruction_ready
		676	avx_cvtdq2pd_reg_mem:
		677	cmp al,'['
		678	jne invalid_operand
		679	mov [mmx_size],cl
		680	call get_address
		681	mov al,[mmx_size]
		682	mov ah,al
		683	xchg al,[operand_size]
		684	or al,al
		685	jz instruction_ready
		686	shl al,1
		687	cmp al,ah
		688	jne invalid_operand_size
		689	jmp instruction_ready
		690	avx_cvtpd2dq_instruction:
		691	mov [opcode_prefix],0F2h
		692	jmp avx_cvtpd_instruction
		693	avx_cvtpd2ps_instruction:
		694	mov [opcode_prefix],66h
		695	avx_cvtpd_instruction:
		696	mov [base_code],0Fh
		697	mov [extended_code],al
		698	or [vex_required],1
		699	call take_avx_register
		700	mov [postbyte_register],al
		701	cmp ah,16
		702	jne invalid_operand
		703	lods byte [esi]
		704	cmp al,','
		705	jne invalid_operand
		706	mov [operand_size],0
		707	lods byte [esi]
		708	call get_size_operator
		709	cmp al,10h
		710	jne avx_cvtpd2dq_reg_mem
		711	lods byte [esi]
		712	call convert_avx_register
		713	mov bl,al
		714	jmp nomem_instruction_ready
		715	avx_cvtpd2dq_reg_mem:
		716	cmp al,'['
		717	jne invalid_operand
		718	call get_address
		719	mov al,[operand_size]
		720	or al,al
		721	jz operand_size_not_specified
		722	cmp al,16
		723	je instruction_ready
		724	cmp al,32
		725	jne invalid_operand_size
		726	jmp instruction_ready
		727	avx_cvttps2dq_instruction:
		728	or [vex_required],2
		729	mov [opcode_prefix],0F3h
		730	mov [mmx_size],0
		731	jmp avx_instruction
		732	avx_cvtsd2si_instruction:
		733	or [vex_required],1
		734	jmp cvtsd2si_instruction
		735	avx_cvtss2si_instruction:
		736	or [vex_required],1
		737	jmp cvtss2si_instruction
		738	avx_cvtsi2ss_instruction:
		739	mov [opcode_prefix],0F3h
		740	jmp avx_cvtsi_instruction
		741	avx_cvtsi2sd_instruction:
		742	mov [opcode_prefix],0F2h
		743	avx_cvtsi_instruction:
		744	mov [base_code],0Fh
		745	mov [extended_code],al
		746	or [vex_required],1
		747	call take_avx_register
		748	cmp ah,16
		749	jne invalid_operand_size
		750	mov [postbyte_register],al
		751	lods byte [esi]
		752	cmp al,','
		753	jne invalid_operand
		754	call take_avx_register
		755	mov [vex_register],al
		756	jmp cvtsi_xmmreg
		757
		758
		759	or [vex_required],1
		760	call setup_66_0f_3a
		761	lods byte [esi]
		762	call get_size_operator
		763	cmp al,10h
		764	je avx_extractf128_reg
		765	cmp al,'['
		766	jne invalid_operand
		767	call get_address
		768	xor al,al
		769	xchg al,[operand_size]
		770	or al,al
		771	jz avx_extractf128_mem_size_ok
		772	cmp al,16
		773	jne invalid_operand_size
		774	avx_extractf128_mem_size_ok:
		775	lods byte [esi]
		776	cmp al,','
		777	jne invalid_operand
		778	call take_avx_register
		779	cmp ah,32
		780	jne invalid_operand_size
		781	mov [postbyte_register],al
		782	jmp mmx_imm8
		783	avx_extractf128_reg:
		784	lods byte [esi]
		785	call convert_xmm_register
		786	mov [operand_size],0
		787	push eax
		788	lods byte [esi]
		789	cmp al,','
		790	jne invalid_operand
		791	call take_avx_register
		792	cmp ah,32
		793	jne invalid_operand_size
		794	mov [postbyte_register],al
		795	pop ebx
		796	jmp mmx_nomem_imm8
		797	setup_66_0f_3a:
		798	mov [extended_code],3Ah
		799	mov [supplemental_code],al
		800	mov [base_code],0Fh
		801	mov [opcode_prefix],66h
		802	ret
		803	avx_insertf128_instruction:
		804	or [vex_required],1
		805	call setup_66_0f_3a
		806	call take_avx_register
		807	cmp ah,32
		808	jne invalid_operand
		809	mov [postbyte_register],al
		810	lods byte [esi]
		811	cmp al,','
		812	jne invalid_operand
		813	call take_avx_register
		814	mov [vex_register],al
		815	mov [operand_size],0
		816	mov [mmx_size],16
		817	lods byte [esi]
		818	cmp al,','
		819	jne invalid_operand
		820	call take_avx_rm
		821	mov [operand_size],32
		822	jnc mmx_imm8
		823	mov bl,al
		824	jmp mmx_nomem_imm8
		825	avx_extractps_instruction:
		826	or [vex_required],1
		827	jmp extractps_instruction
		828	avx_insertps_instruction:
		829	or [vex_required],1
		830	call take_avx_register
		831	cmp ah,16
		832	jne invalid_operand_size
		833	mov [postbyte_register],al
		834	lods byte [esi]
		835	cmp al,','
		836	jne invalid_operand
		837	call take_avx_register
		838	mov [vex_register],al
		839	jmp insertps_xmmreg
		840	avx_pextrb_instruction:
		841	or [vex_required],1
		842	jmp pextrb_instruction
		843	avx_pextrw_instruction:
		844	or [vex_required],1
		845	jmp pextrw_instruction
		846	avx_pextrd_instruction:
		847	or [vex_required],1
		848	jmp pextrd_instruction
		849	avx_pextrq_instruction:
		850	or [vex_required],1
		851	jmp pextrq_instruction
		852	avx_pinsrb_instruction:
		853	mov [mmx_size],1
		854	or [vex_required],1
		855	jmp avx_pinsr_instruction_3a
		856	avx_pinsrw_instruction:
		857	mov [mmx_size],2
		858	or [vex_required],1
		859	jmp avx_pinsr_instruction
		860	avx_pinsrd_instruction:
		861	mov [mmx_size],4
		862	or [vex_required],1
		863	jmp avx_pinsr_instruction_3a
		864	avx_pinsrq_instruction:
		865	mov [mmx_size],8
		866	or [vex_required],1
		867	call operand_64bit
		868	avx_pinsr_instruction_3a:
		869	mov [supplemental_code],al
		870	mov al,3Ah
		871	avx_pinsr_instruction:
		872	mov [opcode_prefix],66h
		873	mov [base_code],0Fh
		874	mov [extended_code],al
		875	call take_avx_register
		876	cmp ah,16
		877	jne invalid_operand_size
		878	mov [postbyte_register],al
		879	lods byte [esi]
		880	cmp al,','
		881	jne invalid_operand
		882	call take_avx_register
		883	mov [vex_register],al
		884	jmp pinsr_xmmreg
		885	avx_maskmovdqu_instruction:
		886	or [vex_required],1
		887	jmp maskmovdqu_instruction
		888	avx_pmovmskb_instruction:
		889	or [vex_required],1
		890	mov [opcode_prefix],66h
		891	mov [base_code],0Fh
		892	mov [extended_code],al
		893	lods byte [esi]
		894	call get_size_operator
		895	cmp al,10h
		896	jne invalid_operand
		897	lods byte [esi]
		898	call convert_register
		899	cmp ah,4
		900	je avx_pmovmskb_reg_size_ok
		901	cmp [code_type],64
		902	jne invalid_operand_size
		903	cmp ah,8
		904	jnz invalid_operand_size
		905	avx_pmovmskb_reg_size_ok:
		906	mov [postbyte_register],al
		907	mov [operand_size],0
		908	lods byte [esi]
		909	cmp al,','
		910	jne invalid_operand
		911	call take_avx_register
		912	mov bl,al
		913	jmp nomem_instruction_ready
		914	avx_pshufd_instruction:
		915	or [vex_required],1
		916	mov [mmx_size],0
		917	mov [opcode_prefix],al
		918	mov [base_code],0Fh
		919	mov [extended_code],70h
		920	call take_avx_register
		921	mov [postbyte_register],al
		922	lods byte [esi]
		923	cmp al,','
		924	jne invalid_operand
		925	call take_avx_rm
		926	jnc mmx_imm8
		927	mov bl,al
		928	jmp mmx_nomem_imm8
		929
		930
		931	mov [mmx_size],8
		932	jmp avx_pmovsx_instruction
		933	avx_pmovsxbd_instruction:
		934	mov [mmx_size],4
		935	jmp avx_pmovsx_instruction
		936	avx_pmovsxbq_instruction:
		937	mov [mmx_size],2
		938	jmp avx_pmovsx_instruction
		939	avx_pmovsxwd_instruction:
		940	mov [mmx_size],8
		941	jmp avx_pmovsx_instruction
		942	avx_pmovsxwq_instruction:
		943	mov [mmx_size],4
		944	jmp avx_pmovsx_instruction
		945	avx_pmovsxdq_instruction:
		946	mov [mmx_size],8
		947	avx_pmovsx_instruction:
		948	or [vex_required],1
		949	call setup_66_0f_38
		950	call take_avx_register
		951	mov [postbyte_register],al
		952	lods byte [esi]
		953	cmp al,','
		954	jne invalid_operand
		955	xor al,al
		956	xchg al,[operand_size]
		957	push eax
		958	lods byte [esi]
		959	call get_size_operator
		960	cmp al,10h
		961	je avx_pmovsx_xmmreg_reg
		962	cmp al,'['
		963	jne invalid_operand
		964	call get_address
		965	pop eax
		966	cmp al,32
		967	jb avx_pmovsx_size_check
		968	shl [mmx_size],1
		969	avx_pmovsx_size_check:
		970	xchg al,[operand_size]
		971	test al,al
		972	jz instruction_ready
		973	cmp al,[mmx_size]
		974	jne invalid_operand_size
		975	jmp instruction_ready
		976	avx_pmovsx_xmmreg_reg:
		977	lods byte [esi]
		978	call convert_xmm_register
		979	mov bl,al
		980	pop eax
		981	mov [operand_size],al
		982	jmp nomem_instruction_ready
		983	avx_permil_instruction:
		984	call setup_66_0f_3a
		985	or [vex_required],1
		986	call take_avx_register
		987	mov [postbyte_register],al
		988	lods byte [esi]
		989	cmp al,','
		990	jne invalid_operand
		991	lods byte [esi]
		992	call get_size_operator
		993	cmp al,'['
		994	je avx_permil_reg_mem
		995	cmp al,10h
		996	jne invalid_operand
		997	lods byte [esi]
		998	call convert_avx_register
		999	mov [vex_register],al
		1000	lods byte [esi]
		1001	cmp al,','
		1002	jne invalid_operand
		1003	push esi
		1004	xor cl,cl
		1005	xchg cl,[operand_size]
		1006	lods byte [esi]
		1007	call get_size_operator
		1008	xchg cl,[operand_size]
		1009	pop esi
		1010	cmp al,'['
		1011	je avx_permil_reg_reg_mem
		1012	cmp al,10h
		1013	jne avx_permil_reg_reg_imm8
		1014	call take_avx_register
		1015	mov bl,al
		1016	mov [extended_code],38h
		1017	add [supplemental_code],8
		1018	jmp nomem_instruction_ready
		1019	avx_permil_reg_reg_mem:
		1020	lods byte [esi]
		1021	call get_size_operator
		1022	call get_address
		1023	mov [extended_code],38h
		1024	add [supplemental_code],8
		1025	jmp instruction_ready
		1026	avx_permil_reg_reg_imm8:
		1027	dec esi
		1028	xor bl,bl
		1029	xchg bl,[vex_register]
		1030	jmp mmx_nomem_imm8
		1031	avx_permil_reg_mem:
		1032	call get_address
		1033	jmp mmx_imm8
		1034	avx_bit_shift_instruction:
		1035	mov [opcode_prefix],66h
		1036	mov [base_code],0Fh
		1037	mov [extended_code],al
		1038	or [vex_required],1
		1039	call take_avx_register
		1040	mov [postbyte_register],al
		1041	lods byte [esi]
		1042	cmp al,','
		1043	jne invalid_operand
		1044	call take_avx_register
		1045	mov [vex_register],al
		1046	lods byte [esi]
		1047	cmp al,','
		1048	jne invalid_operand
		1049	push esi
		1050	xor cl,cl
		1051	xchg cl,[operand_size]
		1052	lods byte [esi]
		1053	call get_size_operator
		1054	cmp al,10h
		1055	je avx_bit_shift_regs_reg
		1056	pop esi
		1057	cmp al,'['
		1058	je avx_bit_shift_regs_mem
		1059	xchg cl,[operand_size]
		1060	dec esi
		1061	mov bl,[extended_code]
		1062	mov al,bl
		1063	shr bl,4
		1064	and al,1111b
		1065	add al,70h
		1066	mov [extended_code],al
		1067	sub bl,0Ch
		1068	shl bl,1
		1069	xchg bl,[postbyte_register]
		1070	xchg bl,[vex_register]
		1071	jmp mmx_nomem_imm8
		1072	avx_bit_shift_regs_reg:
		1073	pop eax
		1074	lods byte [esi]
		1075	call convert_xmm_register
		1076	xchg cl,[operand_size]
		1077	mov bl,al
		1078	jmp nomem_instruction_ready
		1079	avx_bit_shift_regs_mem:
		1080	push ecx
		1081	lods byte [esi]
		1082	call get_size_operator
		1083	call get_address
		1084	pop eax
		1085	xchg al,[operand_size]
		1086	test al,al
		1087	jz instruction_ready
		1088	cmp al,16
		1089	jne invalid_operand_size
		1090	jmp instruction_ready
		1091	avx_pslldq_instruction:
		1092	mov [postbyte_register],al
		1093	mov [opcode_prefix],66h
		1094	mov [base_code],0Fh
		1095	mov [extended_code],73h
		1096	or [vex_required],1
		1097	call take_avx_register
		1098	mov [vex_register],al
		1099	lods byte [esi]
		1100	cmp al,','
		1101	jne invalid_operand
		1102	call take_avx_register
		1103	mov bl,al
		1104	jmp mmx_nomem_imm8
		1105
		1106
		1107	mov [operand_size],32
		1108	vzeroupper_instruction:
		1109	mov [base_code],0Fh
		1110	mov [extended_code],al
		1111	or [vex_required],1
		1112	call store_instruction_code
		1113	jmp instruction_assembled
		1114	vldmxcsr_instruction:
		1115	or [vex_required],1
		1116	jmp fxsave_instruction
		1117	vcvtph2ps_instruction:
		1118	mov [opcode_prefix],66h
		1119	mov [supplemental_code],al
		1120	mov al,38h
		1121	jmp avx_cvtps2pd_instruction
		1122	vcvtps2ph_instruction:
		1123	call setup_66_0f_3a
		1124	or [vex_required],1
		1125	lods byte [esi]
		1126	call get_size_operator
		1127	cmp al,10h
		1128	je vcvtps2ph_reg
		1129	cmp al,'['
		1130	jne invalid_operand
		1131	call get_address
		1132	lods byte [esi]
		1133	cmp al,','
		1134	jne invalid_operand
		1135	shl [operand_size],1
		1136	call take_avx_register
		1137	mov [postbyte_register],al
		1138	jmp mmx_imm8
		1139	vcvtps2ph_reg:
		1140	lods byte [esi]
		1141	call convert_xmm_register
		1142	mov bl,al
		1143	mov [operand_size],0
		1144	lods byte [esi]
		1145	cmp al,','
		1146	jne invalid_operand
		1147	call take_avx_register
		1148	mov [postbyte_register],al
		1149	jmp mmx_nomem_imm8
		1150
		1151
		1152	mov [base_code],0Fh
		1153	mov [extended_code],38h
		1154	mov [supplemental_code],0F3h
		1155	mov [postbyte_register],al
		1156	bmi_reg:
		1157	or [vex_required],1
		1158	lods byte [esi]
		1159	call get_size_operator
		1160	cmp al,10h
		1161	jne invalid_operand
		1162	lods byte [esi]
		1163	call convert_register
		1164	mov [vex_register],al
		1165	lods byte [esi]
		1166	cmp al,','
		1167	jne invalid_operand
		1168	lods byte [esi]
		1169	call get_size_operator
		1170	cmp al,10h
		1171	je bmi_reg_reg
		1172	cmp al,'['
		1173	jne invalid_argument
		1174	call get_address
		1175	call operand_32or64
		1176	jmp instruction_ready
		1177	bmi_reg_reg:
		1178	lods byte [esi]
		1179	call convert_register
		1180	mov bl,al
		1181	call operand_32or64
		1182	jmp nomem_instruction_ready
		1183	operand_32or64:
		1184	mov al,[operand_size]
		1185	cmp al,4
		1186	je operand_32or64_ok
		1187	cmp al,8
		1188	jne invalid_operand_size
		1189	cmp [code_type],64
		1190	jne invalid_operand
		1191	or [rex_prefix],8
		1192	operand_32or64_ok:
		1193	ret
		1194	pdep_instruction:
		1195	mov [opcode_prefix],0F2h
		1196	jmp andn_instruction
		1197	pext_instruction:
		1198	mov [opcode_prefix],0F3h
		1199	andn_instruction:
		1200	mov [base_code],0Fh
		1201	mov [extended_code],38h
		1202	mov [supplemental_code],al
		1203	or [vex_required],1
		1204	lods byte [esi]
		1205	call get_size_operator
		1206	cmp al,10h
		1207	jne invalid_operand
		1208	lods byte [esi]
		1209	call convert_register
		1210	mov [postbyte_register],al
		1211	lods byte [esi]
		1212	cmp al,','
		1213	jne invalid_operand
		1214	jmp bmi_reg
		1215	sarx_instruction:
		1216	mov [opcode_prefix],0F3h
		1217	jmp bzhi_instruction
		1218	shrx_instruction:
		1219	mov [opcode_prefix],0F2h
		1220	jmp bzhi_instruction
		1221	shlx_instruction:
		1222	mov [opcode_prefix],66h
		1223	bzhi_instruction:
		1224	mov [base_code],0Fh
		1225	mov [extended_code],38h
		1226	mov [supplemental_code],al
		1227	or [vex_required],1
		1228	call get_reg_mem
		1229	jc bzhi_reg_reg
		1230	call get_vex_source_register
		1231	jc invalid_operand
		1232	call operand_32or64
		1233	jmp instruction_ready
		1234	bzhi_reg_reg:
		1235	call get_vex_source_register
		1236	jc invalid_operand
		1237	call operand_32or64
		1238	jmp nomem_instruction_ready
		1239	get_vex_source_register:
		1240	lods byte [esi]
		1241	cmp al,','
		1242	jne invalid_operand
		1243	lods byte [esi]
		1244	call get_size_operator
		1245	cmp al,10h
		1246	jne no_vex_source_register
		1247	lods byte [esi]
		1248	call convert_register
		1249	mov [vex_register],al
		1250	clc
		1251	ret
		1252	no_vex_source_register:
		1253	stc
		1254	ret
		1255	bextr_instruction:
		1256	mov [base_code],0Fh
		1257	mov [extended_code],38h
		1258	mov [supplemental_code],al
		1259	or [vex_required],1
		1260	call get_reg_mem
		1261	jc bextr_reg_reg
		1262	call get_vex_source_register
		1263	jc bextr_reg_mem_imm32
		1264	call operand_32or64
		1265	jmp instruction_ready
		1266	bextr_reg_reg:
		1267	call get_vex_source_register
		1268	jc bextr_reg_reg_imm32
		1269	call operand_32or64
		1270	jmp nomem_instruction_ready
		1271	setup_bextr_imm_opcode:
		1272	mov [xop_opcode_map],0Ah
		1273	mov [base_code],10h
		1274	call operand_32or64
		1275	ret
		1276	bextr_reg_mem_imm32:
		1277	call get_imm32
		1278	call setup_bextr_imm_opcode
		1279	jmp store_instruction_with_imm32
		1280	bextr_reg_reg_imm32:
		1281	call get_imm32
		1282	call setup_bextr_imm_opcode
		1283	store_nomem_instruction_with_imm32:
		1284	call store_nomem_instruction
		1285	mov eax,dword [value]
		1286	call mark_relocation
		1287	stos dword [edi]
		1288	jmp instruction_assembled
		1289	get_imm32:
		1290	cmp al,'('
		1291	jne invalid_operand
		1292	push edx ebx ecx
		1293	call get_dword_value
		1294	mov dword [value],eax
		1295	pop ecx ebx edx
		1296	ret
		1297	rorx_instruction:
		1298	mov [opcode_prefix],0F2h
		1299	mov [base_code],0Fh
		1300	mov [extended_code],3Ah
		1301	mov [supplemental_code],al
		1302	or [vex_required],1
		1303	call get_reg_mem
		1304	jc rorx_reg_reg
		1305	call operand_32or64
		1306	jmp mmx_imm8
		1307	rorx_reg_reg:
		1308	call operand_32or64
		1309	jmp mmx_nomem_imm8
		1310
		1311
		1312	or [rex_prefix],8
		1313	fma_instruction_ps:
		1314	mov [mmx_size],0
		1315	jmp avx_instruction_38_setup
		1316	fma_instruction_sd:
		1317	or [rex_prefix],8
		1318	mov [mmx_size],8
		1319	jmp avx_instruction_38_setup
		1320	fma_instruction_ss:
		1321	mov [mmx_size],4
		1322	jmp avx_instruction_38_setup
		1323
		1324
		1325	mov [mmx_size],0
		1326	jmp fma4_instruction_setup
		1327	fma4_instruction_sd:
		1328	mov [mmx_size],8
		1329	jmp fma4_instruction_setup
		1330	fma4_instruction_ss:
		1331	mov [mmx_size],4
		1332	fma4_instruction_setup:
		1333	mov [immediate_size],-2
		1334	mov byte [value],0
		1335	jmp avx_instruction_3a_setup
		1336
		1337
		1338	or [vex_required],2
		1339	mov [mmx_size],8
		1340	jmp xop_instruction_9
		1341	xop_single_source_ss_instruction:
		1342	or [vex_required],2
		1343	mov [mmx_size],4
		1344	jmp xop_instruction_9
		1345	xop_single_source_instruction:
		1346	or [vex_required],2
		1347	mov [mmx_size],0
		1348	xop_instruction_9:
		1349	mov [base_code],al
		1350	mov [xop_opcode_map],9
		1351	jmp avx_common
		1352	xop_single_source_128bit_instruction:
		1353	or [vex_required],2
		1354	mov [mmx_size],16
		1355	jmp xop_instruction_9
		1356	xop_triple_source_128bit_instruction:
		1357	mov [immediate_size],-1
		1358	mov byte [value],0
		1359	mov [mmx_size],16
		1360	jmp xop_instruction_8
		1361	xop_128bit_instruction:
		1362	mov [immediate_size],-2
		1363	mov byte [value],0
		1364	mov [mmx_size],16
		1365	xop_instruction_8:
		1366	mov [base_code],al
		1367	mov [xop_opcode_map],8
		1368	jmp avx_common
		1369	xop_pcom_b_instruction:
		1370	mov ah,0CCh
		1371	jmp xop_pcom_instruction
		1372	xop_pcom_d_instruction:
		1373	mov ah,0CEh
		1374	jmp xop_pcom_instruction
		1375	xop_pcom_q_instruction:
		1376	mov ah,0CFh
		1377	jmp xop_pcom_instruction
		1378	xop_pcom_w_instruction:
		1379	mov ah,0CDh
		1380	jmp xop_pcom_instruction
		1381	xop_pcom_ub_instruction:
		1382	mov ah,0ECh
		1383	jmp xop_pcom_instruction
		1384	xop_pcom_ud_instruction:
		1385	mov ah,0EEh
		1386	jmp xop_pcom_instruction
		1387	xop_pcom_uq_instruction:
		1388	mov ah,0EFh
		1389	jmp xop_pcom_instruction
		1390	xop_pcom_uw_instruction:
		1391	mov ah,0EDh
		1392	xop_pcom_instruction:
		1393	mov byte [value],al
		1394	mov [mmx_size],16
		1395	mov [base_code],ah
		1396	mov [xop_opcode_map],8
		1397	jmp avx_common
		1398	vpcmov_instruction:
		1399	or [vex_required],1
		1400	mov [immediate_size],-2
		1401	mov byte [value],0
		1402	mov [mmx_size],0
		1403	mov [base_code],al
		1404	mov [xop_opcode_map],8
		1405	jmp avx_common
		1406	xop_shift_instruction:
		1407	mov [base_code],al
		1408	or [vex_required],1
		1409	mov [xop_opcode_map],9
		1410	call take_avx_register
		1411	cmp ah,16
		1412	jne invalid_operand
		1413	mov [postbyte_register],al
		1414	lods byte [esi]
		1415	cmp al,','
		1416	jne invalid_operand
		1417	lods byte [esi]
		1418	call get_size_operator
		1419	cmp al,'['
		1420	je xop_shift_reg_mem
		1421	cmp al,10h
		1422	jne invalid_operand
		1423	lods byte [esi]
		1424	call convert_xmm_register
		1425	mov [vex_register],al
		1426	lods byte [esi]
		1427	cmp al,','
		1428	jne invalid_operand
		1429	push esi
		1430	xor cl,cl
		1431	xchg cl,[operand_size]
		1432	lods byte [esi]
		1433	call get_size_operator
		1434	pop esi
		1435	xchg cl,[operand_size]
		1436	cmp al,'['
		1437	je xop_shift_reg_reg_mem
		1438	cmp al,10h
		1439	jne xop_shift_reg_reg_imm
		1440	call take_avx_register
		1441	mov bl,al
		1442	xchg bl,[vex_register]
		1443	jmp nomem_instruction_ready
		1444	xop_shift_reg_reg_mem:
		1445	or [rex_prefix],8
		1446	lods byte [esi]
		1447	call get_size_operator
		1448	call get_address
		1449	jmp instruction_ready
		1450	xop_shift_reg_reg_imm:
		1451	xor bl,bl
		1452	xchg bl,[vex_register]
		1453	cmp [base_code],94h
		1454	jae invalid_operand
		1455	add [base_code],30h
		1456	mov [xop_opcode_map],8
		1457	dec esi
		1458	jmp mmx_nomem_imm8
		1459	xop_shift_reg_mem:
		1460	call get_address
		1461	lods byte [esi]
		1462	cmp al,','
		1463	jne invalid_operand
		1464	push esi
		1465	xor cl,cl
		1466	xchg cl,[operand_size]
		1467	lods byte [esi]
		1468	call get_size_operator
		1469	pop esi
		1470	xchg cl,[operand_size]
		1471	cmp al,10h
		1472	jne xop_shift_reg_mem_imm
		1473	call take_avx_register
		1474	mov [vex_register],al
		1475	jmp instruction_ready
		1476	xop_shift_reg_mem_imm:
		1477	cmp [base_code],94h
		1478	jae invalid_operand
		1479	add [base_code],30h
		1480	mov [xop_opcode_map],8
		1481	dec esi
		1482	jmp mmx_imm8
		1483
		1484
		1485	mov [immediate_size],-2
		1486	mov byte [value],al
		1487	mov al,49h
		1488	jmp vpermil2_instruction_setup
		1489	vpermil_2ps_instruction:
		1490	mov [immediate_size],-2
		1491	mov byte [value],al
		1492	mov al,48h
		1493	jmp vpermil2_instruction_setup
		1494	vpermil2_instruction:
		1495	mov [immediate_size],-3
		1496	mov byte [value],0
		1497	vpermil2_instruction_setup:
		1498	mov [base_code],0Fh
		1499	mov [supplemental_code],al
		1500	mov al,3Ah
		1501	mov [mmx_size],0
		1502	jmp avx_instruction
		1503
		1504
		1505	mov [xop_opcode_map],9
		1506	mov ah,al
		1507	shr ah,4
		1508	and al,111b
		1509	mov [base_code],ah
		1510	mov [postbyte_register],al
		1511	jmp bmi_reg
		1512
		1513
		1514	or [vex_required],1
		1515	mov [xop_opcode_map],9
		1516	mov [base_code],12h
		1517	mov [postbyte_register],al
		1518	lods byte [esi]
		1519	call get_size_operator
		1520	cmp al,10h
		1521	jne invalid_operand
		1522	lods byte [esi]
		1523	call convert_register
		1524	mov bl,al
		1525	call operand_32or64
		1526	jmp nomem_instruction_ready
		1527	lwpins_instruction:
		1528	or [vex_required],1
		1529	mov [xop_opcode_map],0Ah
		1530	mov [base_code],12h
		1531	mov [vex_register],al
		1532	lods byte [esi]
		1533	call get_size_operator
		1534	cmp al,10h
		1535	jne invalid_operand
		1536	lods byte [esi]
		1537	call convert_register
		1538	mov [postbyte_register],al
		1539	lods byte [esi]
		1540	cmp al,','
		1541	jne invalid_operand
		1542	xor cl,cl
		1543	xchg cl,[operand_size]
		1544	lods byte [esi]
		1545	call get_size_operator
		1546	cmp al,10h
		1547	je lwpins_reg_reg
		1548	cmp al,'['
		1549	jne invalid_argument
		1550	push ecx
		1551	call get_address
		1552	pop eax
		1553	xchg al,[operand_size]
		1554	test al,al
		1555	jz lwpins_reg_mem_size_ok
		1556	cmp al,4
		1557	jne invalid_operand_size
		1558	lwpins_reg_mem_size_ok:
		1559	call prepare_lwpins
		1560	jmp store_instruction_with_imm32
		1561	lwpins_reg_reg:
		1562	lods byte [esi]
		1563	call convert_register
		1564	cmp ah,4
		1565	jne invalid_operand_size
		1566	mov [operand_size],cl
		1567	mov bl,al
		1568	call prepare_lwpins
		1569	jmp store_nomem_instruction_with_imm32
		1570	prepare_lwpins:
		1571	lods byte [esi]
		1572	cmp al,','
		1573	jne invalid_operand
		1574	lods byte [esi]
		1575	call get_imm32
		1576	call operand_32or64
		1577	mov al,[vex_register]
		1578	xchg al,[postbyte_register]
		1579	mov [vex_register],al
		1580	ret
		1581
		1582
		1583	or [rex_prefix],8
		1584	gather_instruction_ps:
		1585	call setup_66_0f_38
		1586	or [vex_required],4
		1587	call take_avx_register
		1588	mov [postbyte_register],al
		1589	lods byte [esi]
		1590	cmp al,','
		1591	jne invalid_operand
		1592	xor cl,cl
		1593	xchg cl,[operand_size]
		1594	push ecx
		1595	lods byte [esi]
		1596	call get_size_operator
		1597	cmp al,'['
		1598	jne invalid_argument
		1599	call get_address
		1600	pop eax
		1601	xchg al,[operand_size]
		1602	test al,al
		1603	jz gather_elements_size_ok
		1604	test [rex_prefix],8
		1605	jnz gather_elements_64bit
		1606	cmp al,4
		1607	jne invalid_operand_size
		1608	jmp gather_elements_size_ok
		1609	gather_elements_64bit:
		1610	cmp al,8
		1611	jne invalid_operand_size
		1612	gather_elements_size_ok:
		1613	lods byte [esi]
		1614	cmp al,','
		1615	jne invalid_operand
		1616	call take_avx_register
		1617	mov [vex_register],al
		1618	cmp al,[postbyte_register]
		1619	je disallowed_combination_of_registers
		1620	mov al,bl
		1621	and al,1111b
		1622	cmp al,[postbyte_register]
		1623	je disallowed_combination_of_registers
		1624	cmp al,[vex_register]
		1625	je disallowed_combination_of_registers
		1626	mov al,bl
		1627	shr al,4
		1628	cmp al,0Ch
		1629	je gather_vr_128bit
		1630	mov al,[rex_prefix]
		1631	shr al,3
		1632	xor al,[supplemental_code]
		1633	test al,1
		1634	jz gather_256bit
		1635	test [supplemental_code],1
		1636	jz invalid_operand_size
		1637	mov al,32
		1638	xchg al,[operand_size]
		1639	cmp al,16
		1640	jne invalid_operand_size
		1641	jmp instruction_ready
		1642	gather_256bit:
		1643	cmp ah,32
		1644	jne invalid_operand_size
		1645	jmp instruction_ready
		1646	gather_vr_128bit:
		1647	cmp ah,16
		1648	je instruction_ready
		1649	test [supplemental_code],1
		1650	jnz invalid_operand_size
		1651	test [rex_prefix],8
		1652	jz invalid_operand_size
		1653	jmp instruction_ready
		1654
		1655
		1656	lods byte [esi]
		1657	call get_size_operator
		1658	cmp al,10h
		1659	jne invalid_operand
		1660	lods byte [esi]
		1661	convert_avx_register:
		1662	mov ah,al
		1663	and al,0Fh
		1664	and ah,0F0h
		1665	sub ah,0B0h
		1666	jbe invalid_operand
		1667	cmp ah,32
		1668	ja invalid_operand
		1669	cmp al,8
		1670	jb match_register_size
		1671	cmp [code_type],64
		1672	jne invalid_operand
		1673	jmp match_register_size
		1674	store_vex_instruction_code:
		1675	mov al,[base_code]
		1676	cmp al,0Fh
		1677	jne store_xop_instruction_code
		1678	mov ah,[extended_code]
		1679	cmp ah,38h
		1680	je store_vex_0f38_instruction_code
		1681	cmp ah,3Ah
		1682	je store_vex_0f3a_instruction_code
		1683	test [rex_prefix],1011b
		1684	jnz store_vex_0f_instruction_code
		1685	mov [edi+2],ah
		1686	mov byte [edi],0C5h
		1687	mov al,[vex_register]
		1688	not al
		1689	shl al,3
		1690	mov ah,[rex_prefix]
		1691	shl ah,5
		1692	and ah,80h
		1693	xor al,ah
		1694	call get_vex_lpp_bits
		1695	mov [edi+1],al
		1696	call check_vex
		1697	add edi,3
		1698	ret
		1699	get_vex_lpp_bits:
		1700	cmp [operand_size],32
		1701	jne vex_l_bit_ok
		1702	or al,100b
		1703	vex_l_bit_ok:
		1704	mov ah,[opcode_prefix]
		1705	cmp ah,66h
		1706	je vex_66
		1707	cmp ah,0F3h
		1708	je vex_f3
		1709	cmp ah,0F2h
		1710	je vex_f2
		1711	test ah,ah
		1712	jnz disallowed_combination_of_registers
		1713	ret
		1714	vex_f2:
		1715	or al,11b
		1716	ret
		1717	vex_f3:
		1718	or al,10b
		1719	ret
		1720	vex_66:
		1721	or al,1
		1722	ret
		1723	store_vex_0f38_instruction_code:
		1724	mov al,11100010b
		1725	mov ah,[supplemental_code]
		1726	jmp make_c4_vex
		1727	store_vex_0f3a_instruction_code:
		1728	mov al,11100011b
		1729	mov ah,[supplemental_code]
		1730	jmp make_c4_vex
		1731	store_vex_0f_instruction_code:
		1732	mov al,11100001b
		1733	make_c4_vex:
		1734	mov [edi+3],ah
		1735	mov byte [edi],0C4h
		1736	mov ah,[rex_prefix]
		1737	shl ah,5
		1738	xor al,ah
		1739	mov [edi+1],al
		1740	call check_vex
		1741	mov al,[vex_register]
		1742	xor al,1111b
		1743	shl al,3
		1744	mov ah,[rex_prefix]
		1745	shl ah,4
		1746	and ah,80h
		1747	or al,ah
		1748	call get_vex_lpp_bits
		1749	mov [edi+2],al
		1750	add edi,4
		1751	ret
		1752	check_vex:
		1753	cmp [code_type],64
		1754	je vex_ok
		1755	not al
		1756	test al,11000000b
		1757	jnz invalid_operand
		1758	test [rex_prefix],40h
		1759	jnz invalid_operand
		1760	vex_ok:
		1761	ret
		1762	store_xop_instruction_code:
		1763	mov [edi+3],al
		1764	mov byte [edi],8Fh
		1765	mov al,[xop_opcode_map]
		1766	mov ah,[rex_prefix]
		1767	test ah,40h
		1768	jz xop_ok
		1769	cmp [code_type],64
		1770	jne invalid_operand
		1771	xop_ok:
		1772	not ah
		1773	shl ah,5
		1774	xor al,ah
		1775	mov [edi+1],al
		1776	mov al,[vex_register]
		1777	xor al,1111b
		1778	shl al,3
		1779	mov ah,[rex_prefix]
		1780	shl ah,4
		1781	and ah,80h
		1782	or al,ah
		1783	call get_vex_lpp_bits
		1784	mov [edi+2],al
		1785	add edi,4
		1786	ret
		1787

Subversion Repositories Kolibri OS

(root)/programs/develop/fasm/trunk/avx.inc – Rev 4039