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

Rev	Author	Line No.	Line
2287	heavyiron	1
		2	; Copyright (c) 1999-2012, Tomasz Grysztar.
2664	dunkaist	3	; All rights reserved.
2287	heavyiron	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	avx_instruction:
		71	mov [base_code],0Fh
		72	mov [extended_code],al
		73	avx_common:
		74	or [vex_required],1
		75	lods byte [esi]
		76	call get_size_operator
		77	cmp al,10h
		78	jne invalid_operand
		79	avx_reg:
		80	lods byte [esi]
		81	call convert_avx_register
		82	mov [postbyte_register],al
		83	avx_vex_reg:
		84	test [vex_required],2
		85	jnz avx_vex_reg_ok
		86	lods byte [esi]
		87	cmp al,','
		88	jne invalid_operand
		89	call take_avx_register
		90	mov [vex_register],al
		91	avx_vex_reg_ok:
		92	cmp [mmx_size],0
		93	je avx_regs_size_ok
		94	cmp ah,16
		95	jne invalid_operand
		96	avx_regs_size_ok:
		97	lods byte [esi]
		98	cmp al,','
		99	jne invalid_operand
		100	call take_avx_rm
		101	jc avx_regs_reg
		102	mov al,[extended_code]
		103	mov ah,[supplemental_code]
		104	cmp al,0C2h
		105	je sse_cmp_mem_ok
		106	cmp ax,443Ah
		107	je sse_cmp_mem_ok
		108	mov al,[base_code]
		109	and al,11011100b
		110	cmp al,11001100b
		111	je sse_cmp_mem_ok
		112	cmp [immediate_size],1
		113	je mmx_imm8
		114	cmp [immediate_size],0
		115	jge instruction_ready
		116	cmp byte [esi],','
		117	jne invalid_operand
		118	inc esi
		119	call take_avx_register
		120	shl al,4
		121	or byte [value],al
		122	test al,80h
		123	jz avx_regs_mem_reg_store
		124	cmp [code_type],64
		125	jne invalid_operand
		126	avx_regs_mem_reg_store:
		127	call take_imm4_if_needed
		128	call store_instruction_with_imm8
		129	jmp instruction_assembled
		130	avx_regs_reg:
		131	mov bl,al
		132	mov al,[extended_code]
		133	mov ah,[supplemental_code]
		134	cmp al,0C2h
		135	je sse_cmp_nomem_ok
		136	cmp ax,443Ah
		137	je sse_cmp_nomem_ok
		138	mov al,[base_code]
		139	and al,11011100b
		140	cmp al,11001100b
		141	je sse_cmp_nomem_ok
		142	cmp [immediate_size],1
		143	je mmx_nomem_imm8
		144	cmp [immediate_size],0
		145	jge nomem_instruction_ready
		146	lods byte [esi]
		147	cmp al,','
		148	jne invalid_operand
		149	mov al,bl
		150	shl al,4
		151	or byte [value],al
		152	test al,80h
		153	jz avx_regs_reg_
		154	cmp [code_type],64
		155	jne invalid_operand
		156	avx_regs_reg_:
		157	call take_avx_rm
		158	jc avx_regs_reg_reg
		159	cmp [immediate_size],-2
		160	jg invalid_operand
		161	or [rex_prefix],8
		162	call take_imm4_if_needed
		163	call store_instruction_with_imm8
		164	jmp instruction_assembled
		165	avx_regs_reg_reg:
		166	shl al,4
		167	and byte [value],1111b
		168	or byte [value],al
		169	call take_imm4_if_needed
		170	call store_nomem_instruction
		171	mov al,byte [value]
		172	stos byte [edi]
		173	jmp instruction_assembled
		174	take_avx_rm:
		175	xor cl,cl
		176	xchg cl,[operand_size]
		177	lods byte [esi]
		178	call get_size_operator
		179	cmp al,'['
		180	je take_avx_mem
		181	mov [operand_size],cl
		182	cmp al,10h
		183	jne invalid_operand
		184	lods byte [esi]
		185	call convert_avx_register
		186	cmp [mmx_size],0
		187	je avx_reg_ok
		188	cmp ah,16
		189	jne invalid_operand
		190	avx_reg_ok:
		191	stc
		192	ret
		193	take_avx_mem:
		194	push ecx
		195	call get_address
		196	pop eax
		197	cmp [mmx_size],0
		198	jne avx_smem
		199	xchg al,[operand_size]
		200	or al,al
		201	jz avx_mem_ok
		202	cmp al,[operand_size]
		203	jne operand_sizes_do_not_match
		204	avx_mem_ok:
		205	clc
		206	ret
		207	avx_smem:
		208	xchg al,[operand_size]
		209	cmp al,[mmx_size]
		210	jne invalid_operand_size
		211	clc
		212	ret
		213	take_imm4_if_needed:
		214	cmp [immediate_size],-3
		215	jne imm4_ok
		216	push ebx ecx edx
		217	lods byte [esi]
		218	cmp al,','
		219	jne invalid_operand
		220	lods byte [esi]
		221	cmp al,'('
		222	jne invalid_operand
		223	call get_byte_value
		224	test al,11110000b
		225	jnz value_out_of_range
		226	or byte [value],al
		227	pop edx ecx ebx
		228	imm4_ok:
		229	ret
		230
		231
		232	mov [mmx_size],16
		233	mov [opcode_prefix],66h
		234	jmp avx_instruction
		235	avx_single_source_128bit_instruction_38:
		236	or [vex_required],2
		237	avx_128bit_instruction_38:
		238	mov [mmx_size],16
		239	avx_instruction_38_setup:
		240	mov [opcode_prefix],66h
		241	mov [supplemental_code],al
		242	mov al,38h
		243	jmp avx_instruction
		244	avx_single_source_instruction_38:
		245	or [vex_required],2
		246	mov [mmx_size],0
		247	jmp avx_instruction_38_setup
		248	avx_ss_instruction_3a_imm8:
		249	mov [mmx_size],4
		250	jmp avx_instruction_3a_imm8_setup
		251	avx_sd_instruction_3a_imm8:
		252	mov [mmx_size],8
		253	jmp avx_instruction_3a_imm8_setup
		254	avx_single_source_128bit_instruction_3a_imm8:
		255	or [vex_required],2
		256	avx_128bit_instruction_3a_imm8:
		257	mov [mmx_size],16
		258	jmp avx_instruction_3a_imm8_setup
		259	avx_triple_source_instruction_3a:
		260	mov [mmx_size],0
		261	mov [immediate_size],-1
		262	mov byte [value],0
		263	jmp avx_instruction_3a_setup
		264	avx_triple_source_128bit_instruction_3a:
		265	mov [mmx_size],16
		266	mov [immediate_size],-1
		267	mov byte [value],0
		268	jmp avx_instruction_3a_setup
		269	avx_single_source_instruction_3a_imm8:
		270	or [vex_required],2
		271	avx_instruction_3a_imm8:
		272	mov [mmx_size],0
		273	avx_instruction_3a_imm8_setup:
		274	mov [immediate_size],1
		275	avx_instruction_3a_setup:
		276	mov [opcode_prefix],66h
		277	mov [supplemental_code],al
		278	mov al,3Ah
		279	jmp avx_instruction
		280	avx_pclmulqdq_instruction:
		281	mov byte [value],al
		282	mov [mmx_size],16
		283	mov al,44h
		284	jmp avx_instruction_3a_setup
		285	avx_perm2f128_instruction:
		286	call setup_66_0f_3a
		287	mov [immediate_size],1
		288	mov [mmx_size],0
		289	or [vex_required],1
		290	call take_avx_register
		291	cmp ah,32
		292	jne invalid_operand_size
		293	mov [postbyte_register],al
		294	jmp avx_vex_reg
		295	setup_66_0f_3a:
		296	mov [opcode_prefix],66h
		297	mov [base_code],0Fh
		298	mov [extended_code],3Ah
		299	mov [supplemental_code],al
		300	ret
		301
		302
		303	mov [opcode_prefix],0F3h
		304	jmp avx_movps_instruction
		305	avx_movpd_instruction:
		306	mov [opcode_prefix],66h
		307	avx_movps_instruction:
		308	mov [mmx_size],0
		309	or [vex_required],2
		310	mov [base_code],0Fh
		311	mov [extended_code],al
		312	lods byte [esi]
		313	call get_size_operator
		314	cmp al,10h
		315	je avx_reg
		316	inc [extended_code]
		317	test [extended_code],1
		318	jnz avx_mem
		319	add [extended_code],-1+10h
		320	avx_mem:
		321	cmp al,'['
		322	jne invalid_operand
		323	call get_address
		324	lods byte [esi]
		325	cmp al,','
		326	jne invalid_operand
		327	call take_avx_register
		328	mov [postbyte_register],al
		329	jmp instruction_ready
		330	avx_movntpd_instruction:
		331	mov [opcode_prefix],66h
		332	avx_movntps_instruction:
		333	or [vex_required],1
		334	mov [base_code],0Fh
		335	mov [extended_code],al
		336	lods byte [esi]
		337	call get_size_operator
		338	jmp avx_mem
		339	avx_lddqu_instruction:
		340	mov [opcode_prefix],0F2h
		341	mov [mmx_size],0
		342	xor cl,cl
		343	avx_load_instruction:
		344	mov [base_code],0Fh
		345	mov [extended_code],al
		346	or [vex_required],1
		347	call take_avx_register
		348	or cl,cl
		349	jz avx_load_reg_ok
		350	cmp ah,cl
		351	jne invalid_operand
		352	avx_load_reg_ok:
		353	cmp [mmx_size],0
		354	je avx_load_reg_
		355	xor ah,ah
		356	avx_load_reg_:
		357	xchg ah,[operand_size]
		358	push eax
		359	lods byte [esi]
		360	cmp al,','
		361	jne invalid_operand
		362	lods byte [esi]
		363	call get_size_operator
		364	cmp al,'['
		365	jne invalid_operand
		366	call get_address
		367	pop eax
		368	xchg ah,[operand_size]
		369	mov [postbyte_register],al
		370	mov al,[mmx_size]
		371	or al,al
		372	jz instruction_ready
		373	or ah,ah
		374	jz instruction_ready
		375	cmp al,ah
		376	jne invalid_operand_size
		377	jmp instruction_ready
		378	avx_movntdqa_instruction:
		379	mov [mmx_size],16
		380	mov al,2Ah
		381	mov cl,16
		382	jmp avx_load_instruction_38
		383	avx_broadcastss_instruction:
		384	mov [mmx_size],4
		385	mov al,18h
		386	xor cl,cl
		387	jmp avx_load_instruction_38
		388	avx_broadcastsd_instruction:
		389	mov [mmx_size],8
		390	mov al,19h
		391	mov cl,32
		392	jmp avx_load_instruction_38
		393	avx_broadcastf128_instruction:
		394	mov [mmx_size],16
		395	mov al,1Ah
		396	mov cl,32
		397	avx_load_instruction_38:
		398	mov [opcode_prefix],66h
		399	mov [supplemental_code],al
		400	mov al,38h
		401	jmp avx_load_instruction
		402	avx_movlpd_instruction:
		403	mov [opcode_prefix],66h
		404	avx_movlps_instruction:
		405	mov [base_code],0Fh
		406	mov [extended_code],al
		407	mov [mmx_size],8
		408	or [vex_required],1
		409	lods byte [esi]
		410	call get_size_operator
		411	cmp al,10h
		412	jne avx_movlps_mem
		413	lods byte [esi]
		414	call convert_avx_register
		415	mov [postbyte_register],al
		416	lods byte [esi]
		417	cmp al,','
		418	jne invalid_operand
		419	call take_avx_register
		420	mov [vex_register],al
		421	cmp [operand_size],16
		422	jne invalid_operand
		423	mov [operand_size],0
		424	lods byte [esi]
		425	cmp al,','
		426	jne invalid_operand
		427	call take_avx_rm
		428	jc invalid_operand
		429	jmp instruction_ready
		430	avx_movlps_mem:
		431	cmp al,'['
		432	jne invalid_operand
		433	call get_address
		434	mov al,[operand_size]
		435	or al,al
		436	jz avx_movlps_mem_size_ok
		437	cmp al,[mmx_size]
		438	jne invalid_operand_size
		439	mov [operand_size],0
		440	avx_movlps_mem_size_ok:
		441	lods byte [esi]
		442	cmp al,','
		443	jne invalid_operand
		444	call take_avx_register
		445	cmp ah,16
		446	jne invalid_operand
		447	mov [postbyte_register],al
		448	inc [extended_code]
		449	jmp instruction_ready
		450	avx_movhlps_instruction:
		451	mov [base_code],0Fh
		452	mov [extended_code],al
		453	or [vex_required],1
		454	call take_avx_register
		455	cmp ah,16
		456	jne invalid_operand
		457	mov [postbyte_register],al
		458	lods byte [esi]
		459	cmp al,','
		460	jne invalid_operand
		461	call take_avx_register
		462	mov [vex_register],al
		463	lods byte [esi]
		464	cmp al,','
		465	jne invalid_operand
		466	call take_avx_register
		467	mov bl,al
		468	jmp nomem_instruction_ready
		469	avx_maskmov_instruction:
		470	mov [opcode_prefix],66h
		471	mov [base_code],0Fh
		472	mov [extended_code],38h
		473	mov [supplemental_code],al
		474	mov [mmx_size],0
		475	or [vex_required],1
		476	lods byte [esi]
		477	call get_size_operator
		478	cmp al,10h
		479	jne avx_maskmov_mem
		480	lods byte [esi]
		481	call convert_avx_register
		482	mov [postbyte_register],al
		483	lods byte [esi]
		484	cmp al,','
		485	jne invalid_operand
		486	call take_avx_register
		487	mov [vex_register],al
		488	lods byte [esi]
		489	cmp al,','
		490	jne invalid_operand
		491	call take_avx_rm
		492	jc invalid_operand
		493	jmp instruction_ready
		494	avx_maskmov_mem:
		495	cmp al,'['
		496	jne invalid_operand
		497	call get_address
		498	lods byte [esi]
		499	cmp al,','
		500	jne invalid_operand
		501	call take_avx_register
		502	mov [vex_register],al
		503	lods byte [esi]
		504	cmp al,','
		505	jne invalid_operand
		506	call take_avx_register
		507	mov [postbyte_register],al
		508	add [supplemental_code],2
		509	jmp instruction_ready
		510	avx_movd_instruction:
		511	or [vex_required],1
		512	jmp movd_instruction
		513	avx_movq_instruction:
		514	or [vex_required],1
		515	jmp movq_instruction
		516	avx_movddup_instruction:
		517	or [vex_required],1
		518	mov [opcode_prefix],0F2h
		519	mov [base_code],0Fh
		520	mov [extended_code],al
		521	lods byte [esi]
		522	call get_size_operator
		523	cmp al,10h
		524	jne invalid_operand
		525	lods byte [esi]
		526	call convert_avx_register
		527	mov [postbyte_register],al
		528	mov [mmx_size],0
		529	cmp ah,32
		530	je avx_regs_size_ok
		531	mov [mmx_size],8
		532	jmp avx_regs_size_ok
		533	avx_movmskpd_instruction:
		534	mov [opcode_prefix],66h
		535	avx_movmskps_instruction:
		536	mov [base_code],0Fh
		537	mov [extended_code],50h
		538	or [vex_required],1
		539	lods byte [esi]
		540	call get_size_operator
		541	cmp al,10h
		542	jne invalid_operand
		543	lods byte [esi]
		544	call convert_register
		545	mov [postbyte_register],al
		546	cmp ah,4
		547	je avx_movmskps_reg_ok
		548	cmp ah,8
		549	jne invalid_operand_size
		550	cmp [code_type],64
		551	jne invalid_operand
		552	avx_movmskps_reg_ok:
		553	mov [operand_size],0
		554	lods byte [esi]
		555	cmp al,','
		556	jne invalid_operand
		557	call take_avx_register
		558	mov bl,al
		559	jmp nomem_instruction_ready
		560	avx_movsd_instruction:
		561	mov [opcode_prefix],0F2h
		562	mov [mmx_size],8
		563	jmp avx_movs_instruction
		564	avx_movss_instruction:
		565	mov [opcode_prefix],0F3h
		566	mov [mmx_size],4
		567	avx_movs_instruction:
		568	or [vex_required],1
		569	mov [base_code],0Fh
		570	mov [extended_code],10h
		571	lods byte [esi]
		572	call get_size_operator
		573	cmp al,10h
		574	jne avx_movlps_mem
		575	lods byte [esi]
		576	call convert_xmm_register
		577	mov [postbyte_register],al
		578	xor cl,cl
		579	xchg cl,[operand_size]
		580	lods byte [esi]
		581	cmp al,','
		582	jne invalid_operand
		583	lods byte [esi]
		584	call get_size_operator
		585	cmp al,10h
		586	jne avx_movs_reg_mem
		587	mov [operand_size],cl
		588	lods byte [esi]
		589	call convert_avx_register
		590	mov [vex_register],al
		591	lods byte [esi]
		592	cmp al,','
		593	jne invalid_operand
		594	call take_avx_register
		595	mov bl,al
		596	cmp bl,8
		597	jb nomem_instruction_ready
		598	inc [extended_code]
		599	xchg bl,[postbyte_register]
		600	jmp nomem_instruction_ready
		601	avx_movs_reg_mem:
		602	cmp al,'['
		603	jne invalid_operand
		604	call get_address
		605	mov al,[operand_size]
		606	or al,al
		607	jz avx_movs_reg_mem_ok
		608	cmp al,[mmx_size]
		609	jne invalid_operand_size
		610	avx_movs_reg_mem_ok:
		611	jmp instruction_ready
		612
		613
		614	mov [opcode_prefix],0F3h
		615	avx_cvtps2pd_instruction:
		616	mov [base_code],0Fh
		617	mov [extended_code],al
		618	or [vex_required],1
		619	call take_avx_register
		620	mov [postbyte_register],al
		621	lods byte [esi]
		622	cmp al,','
		623	jne invalid_operand
		624	xor cl,cl
		625	xchg cl,[operand_size]
		626	lods byte [esi]
		627	call get_size_operator
		628	cmp al,10h
		629	jne avx_cvtdq2pd_reg_mem
		630	lods byte [esi]
		631	call convert_xmm_register
		632	mov bl,al
		633	mov [operand_size],cl
		634	jmp nomem_instruction_ready
		635	avx_cvtdq2pd_reg_mem:
		636	cmp al,'['
		637	jne invalid_operand
		638	mov [mmx_size],cl
		639	call get_address
		640	mov al,[operand_size]
		641	or al,al
		642	jz instruction_ready
		643	shl al,1
		644	cmp al,[mmx_size]
		645	jne invalid_operand_size
		646	mov [operand_size],al
		647	jmp instruction_ready
		648	avx_cvtpd2dq_instruction:
		649	mov [opcode_prefix],0F2h
		650	jmp avx_cvtpd_instruction
		651	avx_cvtpd2ps_instruction:
		652	mov [opcode_prefix],66h
		653	avx_cvtpd_instruction:
		654	mov [base_code],0Fh
		655	mov [extended_code],al
		656	or [vex_required],1
		657	call take_avx_register
		658	mov [postbyte_register],al
		659	cmp ah,16
		660	jne invalid_operand
		661	lods byte [esi]
		662	cmp al,','
		663	jne invalid_operand
		664	mov [operand_size],0
		665	lods byte [esi]
		666	call get_size_operator
		667	cmp al,10h
		668	jne avx_cvtpd2dq_reg_mem
		669	lods byte [esi]
		670	call convert_avx_register
		671	mov bl,al
		672	jmp nomem_instruction_ready
		673	avx_cvtpd2dq_reg_mem:
		674	cmp al,'['
		675	jne invalid_operand
		676	call get_address
		677	mov al,[operand_size]
		678	or al,al
		679	jz operand_size_not_specified
		680	cmp al,16
		681	je instruction_ready
		682	cmp al,32
		683	jne invalid_operand_size
		684	jmp instruction_ready
		685	avx_cvttps2dq_instruction:
		686	or [vex_required],2
		687	mov [opcode_prefix],0F3h
		688	mov [mmx_size],0
		689	jmp avx_instruction
		690	avx_cvtsd2si_instruction:
		691	or [vex_required],1
		692	jmp cvtsd2si_instruction
		693	avx_cvtss2si_instruction:
		694	or [vex_required],1
		695	jmp cvtss2si_instruction
		696	avx_cvtsi2ss_instruction:
		697	mov [opcode_prefix],0F3h
		698	jmp avx_cvtsi_instruction
		699	avx_cvtsi2sd_instruction:
		700	mov [opcode_prefix],0F2h
		701	avx_cvtsi_instruction:
		702	mov [base_code],0Fh
		703	mov [extended_code],al
		704	or [vex_required],1
		705	call take_avx_register
		706	cmp ah,16
		707	jne invalid_operand_size
		708	mov [postbyte_register],al
		709	lods byte [esi]
		710	cmp al,','
		711	jne invalid_operand
		712	call take_avx_register
		713	mov [vex_register],al
		714	jmp cvtsi_xmmreg
		715
		716
		717	or [vex_required],1
		718	call setup_66_0f_3a
		719	lods byte [esi]
		720	call get_size_operator
		721	cmp al,10h
		722	je avx_extractf128_reg
		723	cmp al,'['
		724	jne invalid_operand
		725	call get_address
		726	xor al,al
		727	xchg al,[operand_size]
		728	or al,al
		729	jz avx_extractf128_mem_size_ok
		730	cmp al,16
		731	jne invalid_operand_size
		732	avx_extractf128_mem_size_ok:
		733	lods byte [esi]
		734	cmp al,','
		735	jne invalid_operand
		736	call take_avx_register
		737	cmp ah,32
		738	jne invalid_operand_size
		739	mov [postbyte_register],al
		740	jmp mmx_imm8
		741	avx_extractf128_reg:
		742	lods byte [esi]
		743	call convert_xmm_register
		744	mov [operand_size],0
		745	push eax
		746	lods byte [esi]
		747	cmp al,','
		748	jne invalid_operand
		749	call take_avx_register
		750	cmp ah,32
		751	jne invalid_operand_size
		752	mov [postbyte_register],al
		753	pop ebx
		754	jmp mmx_nomem_imm8
		755	avx_insertf128_instruction:
		756	or [vex_required],1
		757	call setup_66_0f_3a
		758	call take_avx_register
		759	cmp ah,32
		760	jne invalid_operand
		761	mov [postbyte_register],al
		762	lods byte [esi]
		763	cmp al,','
		764	jne invalid_operand
		765	call take_avx_register
		766	mov [vex_register],al
		767	mov [operand_size],0
		768	mov [mmx_size],16
		769	lods byte [esi]
		770	cmp al,','
		771	jne invalid_operand
		772	call take_avx_rm
		773	mov [operand_size],32
		774	jnc mmx_imm8
		775	mov bl,al
		776	jmp mmx_nomem_imm8
		777	avx_extractps_instruction:
		778	or [vex_required],1
		779	jmp extractps_instruction
		780	avx_insertps_instruction:
		781	or [vex_required],1
		782	call take_avx_register
		783	cmp ah,16
		784	jne invalid_operand_size
		785	mov [postbyte_register],al
		786	lods byte [esi]
		787	cmp al,','
		788	jne invalid_operand
		789	call take_avx_register
		790	mov [vex_register],al
		791	jmp insertps_xmmreg
		792	avx_pextrb_instruction:
		793	or [vex_required],1
		794	jmp pextrb_instruction
		795	avx_pextrw_instruction:
		796	or [vex_required],1
		797	jmp pextrw_instruction
		798	avx_pextrd_instruction:
		799	or [vex_required],1
		800	jmp pextrd_instruction
		801	avx_pextrq_instruction:
		802	or [vex_required],1
		803	jmp pextrq_instruction
		804	avx_pinsrb_instruction:
		805	mov [mmx_size],1
		806	or [vex_required],1
		807	jmp avx_pinsr_instruction_3a
		808	avx_pinsrw_instruction:
		809	mov [mmx_size],2
		810	or [vex_required],1
		811	jmp avx_pinsr_instruction
		812	avx_pinsrd_instruction:
		813	mov [mmx_size],4
		814	or [vex_required],1
		815	jmp avx_pinsr_instruction_3a
		816	avx_pinsrq_instruction:
		817	mov [mmx_size],8
		818	or [vex_required],1
		819	call operand_64bit
		820	avx_pinsr_instruction_3a:
		821	mov [supplemental_code],al
		822	mov al,3Ah
		823	avx_pinsr_instruction:
		824	mov [opcode_prefix],66h
		825	mov [base_code],0Fh
		826	mov [extended_code],al
		827	call take_avx_register
		828	cmp ah,16
		829	jne invalid_operand_size
		830	mov [postbyte_register],al
		831	lods byte [esi]
		832	cmp al,','
		833	jne invalid_operand
		834	call take_avx_register
		835	mov [vex_register],al
		836	jmp pinsr_xmmreg
		837	avx_maskmovdqu_instruction:
		838	or [vex_required],1
		839	jmp maskmovdqu_instruction
		840	avx_pmovmskb_instruction:
		841	or [vex_required],1
		842	jmp pmovmskb_instruction
		843	avx_pshufd_instruction:
		844	or [vex_required],1
		845	jmp pshufd_instruction
		846	avx_pmovsxbw_instruction:
		847	mov [mmx_size],8
		848	jmp avx_pmovsx_instruction
		849	avx_pmovsxbd_instruction:
		850	mov [mmx_size],4
		851	jmp avx_pmovsx_instruction
		852	avx_pmovsxbq_instruction:
		853	mov [mmx_size],2
		854	jmp avx_pmovsx_instruction
		855	avx_pmovsxwd_instruction:
		856	mov [mmx_size],8
		857	jmp avx_pmovsx_instruction
		858	avx_pmovsxwq_instruction:
		859	mov [mmx_size],4
		860	jmp avx_pmovsx_instruction
		861	avx_pmovsxdq_instruction:
		862	mov [mmx_size],8
		863	avx_pmovsx_instruction:
		864	or [vex_required],1
		865	jmp pmovsx_instruction
		866	avx_permil_instruction:
		867	call setup_66_0f_3a
		868	or [vex_required],1
		869	call take_avx_register
		870	mov [postbyte_register],al
		871	lods byte [esi]
		872	cmp al,','
		873	jne invalid_operand
		874	lods byte [esi]
		875	call get_size_operator
		876	cmp al,'['
		877	je avx_permil_reg_mem
		878	cmp al,10h
		879	jne invalid_operand
		880	lods byte [esi]
		881	call convert_avx_register
		882	mov [vex_register],al
		883	lods byte [esi]
		884	cmp al,','
		885	jne invalid_operand
		886	push esi
		887	xor cl,cl
		888	xchg cl,[operand_size]
		889	lods byte [esi]
		890	call get_size_operator
		891	xchg cl,[operand_size]
		892	pop esi
		893	cmp al,'['
		894	je avx_permil_reg_reg_mem
		895	cmp al,10h
		896	jne avx_permil_reg_reg_imm8
		897	call take_avx_register
		898	mov bl,al
		899	mov [extended_code],38h
		900	add [supplemental_code],8
		901	jmp nomem_instruction_ready
		902	avx_permil_reg_reg_mem:
		903	lods byte [esi]
		904	call get_size_operator
		905	call get_address
		906	mov [extended_code],38h
		907	add [supplemental_code],8
		908	jmp instruction_ready
		909	avx_permil_reg_reg_imm8:
		910	dec esi
		911	xor bl,bl
		912	xchg bl,[vex_register]
		913	jmp mmx_nomem_imm8
		914	avx_permil_reg_mem:
		915	call get_address
		916	jmp mmx_imm8
		917	avx_pslldq_instruction:
		918	mov [postbyte_register],al
		919	mov [opcode_prefix],66h
		920	mov [base_code],0Fh
		921	mov [extended_code],73h
		922	or [vex_required],1
		923	call take_avx_register
		924	cmp ah,16
		925	jne invalid_operand
		926	mov [vex_register],al
		927	lods byte [esi]
		928	cmp al,','
		929	jne invalid_operand
		930	call take_avx_register
		931	mov bl,al
		932	jmp mmx_nomem_imm8
		933	avx_bit_shift_instruction:
		934	mov [opcode_prefix],66h
		935	mov [base_code],0Fh
		936	mov [extended_code],al
		937	or [vex_required],1
		938	call take_avx_register
		939	cmp ah,16
		940	jne invalid_operand
		941	mov [postbyte_register],al
		942	lods byte [esi]
		943	cmp al,','
		944	jne invalid_operand
		945	call take_avx_register
		946	mov [vex_register],al
		947	lods byte [esi]
		948	cmp al,','
		949	jne invalid_operand
		950	push esi
		951	xor cl,cl
		952	xchg cl,[operand_size]
		953	lods byte [esi]
		954	call get_size_operator
		955	xchg cl,[operand_size]
		956	pop esi
		957	cmp al,10h
		958	je avx_bit_shift_regs_reg
		959	cmp al,'['
		960	je avx_bit_shift_regs_mem
		961	dec esi
		962	mov bl,[extended_code]
		963	mov al,bl
		964	shr bl,4
		965	and al,1111b
		966	add al,70h
		967	mov [extended_code],al
		968	sub bl,0Ch
		969	shl bl,1
		970	xchg bl,[postbyte_register]
		971	xchg bl,[vex_register]
		972	jmp mmx_nomem_imm8
		973	avx_bit_shift_regs_reg:
		974	call take_avx_register
		975	mov bl,al
		976	jmp nomem_instruction_ready
		977	avx_bit_shift_regs_mem:
		978	lods byte [esi]
		979	call get_size_operator
		980	call get_address
		981	jmp instruction_ready
		982
		983
		984	mov [operand_size],32
		985	vzeroupper_instruction:
		986	mov [base_code],0Fh
		987	mov [extended_code],al
		988	or [vex_required],1
		989	call store_instruction_code
		990	jmp instruction_assembled
		991	vldmxcsr_instruction:
		992	or [vex_required],1
		993	jmp fxsave_instruction
		994	vcvtph2ps_instruction:
		995	mov [opcode_prefix],66h
		996	mov [supplemental_code],al
		997	mov al,38h
		998	jmp avx_cvtps2pd_instruction
		999	vcvtps2ph_instruction:
		1000	call setup_66_0f_3a
		1001	or [vex_required],1
		1002	lods byte [esi]
		1003	call get_size_operator
		1004	cmp al,10h
		1005	je vcvtps2ph_reg
		1006	cmp al,'['
		1007	jne invalid_operand
		1008	call get_address
		1009	lods byte [esi]
		1010	cmp al,','
		1011	jne invalid_operand
		1012	shl [operand_size],1
		1013	call take_avx_register
		1014	mov [postbyte_register],al
		1015	jmp mmx_imm8
		1016	vcvtps2ph_reg:
		1017	lods byte [esi]
		1018	call convert_xmm_register
		1019	mov bl,al
		1020	mov [operand_size],0
		1021	lods byte [esi]
		1022	cmp al,','
		1023	jne invalid_operand
		1024	call take_avx_register
		1025	mov [postbyte_register],al
		1026	jmp mmx_nomem_imm8
		1027
		1028
		1029	or [rex_prefix],8
		1030	fma_instruction_ps:
		1031	mov [mmx_size],0
		1032	jmp avx_instruction_38_setup
		1033	fma_instruction_sd:
		1034	or [rex_prefix],8
		1035	mov [mmx_size],8
		1036	jmp avx_instruction_38_setup
		1037	fma_instruction_ss:
		1038	mov [mmx_size],4
		1039	jmp avx_instruction_38_setup
		1040
		1041
		1042	mov [mmx_size],0
		1043	jmp fma4_instruction_setup
		1044	fma4_instruction_sd:
		1045	mov [mmx_size],8
		1046	jmp fma4_instruction_setup
		1047	fma4_instruction_ss:
		1048	mov [mmx_size],4
		1049	fma4_instruction_setup:
		1050	mov [immediate_size],-2
		1051	mov byte [value],0
		1052	jmp avx_instruction_3a_setup
		1053
		1054
		1055	or [vex_required],2
		1056	mov [mmx_size],8
		1057	jmp xop_instruction_9
		1058	xop_single_source_ss_instruction:
		1059	or [vex_required],2
		1060	mov [mmx_size],4
		1061	jmp xop_instruction_9
		1062	xop_single_source_instruction:
		1063	or [vex_required],2
		1064	mov [mmx_size],0
		1065	xop_instruction_9:
		1066	mov [base_code],al
		1067	mov [xop_opcode_map],9
		1068	jmp avx_common
		1069	xop_single_source_128bit_instruction:
		1070	or [vex_required],2
		1071	mov [mmx_size],16
		1072	jmp xop_instruction_9
		1073	xop_triple_source_128bit_instruction:
		1074	mov [immediate_size],-1
		1075	mov byte [value],0
		1076	mov [mmx_size],16
		1077	jmp xop_instruction_8
		1078	xop_128bit_instruction:
		1079	mov [immediate_size],-2
		1080	mov byte [value],0
		1081	mov [mmx_size],16
		1082	xop_instruction_8:
		1083	mov [base_code],al
		1084	mov [xop_opcode_map],8
		1085	jmp avx_common
		1086	xop_pcom_b_instruction:
		1087	mov ah,0CCh
		1088	jmp xop_pcom_instruction
		1089	xop_pcom_d_instruction:
		1090	mov ah,0CEh
		1091	jmp xop_pcom_instruction
		1092	xop_pcom_q_instruction:
		1093	mov ah,0CFh
		1094	jmp xop_pcom_instruction
		1095	xop_pcom_w_instruction:
		1096	mov ah,0CDh
		1097	jmp xop_pcom_instruction
		1098	xop_pcom_ub_instruction:
		1099	mov ah,0ECh
		1100	jmp xop_pcom_instruction
		1101	xop_pcom_ud_instruction:
		1102	mov ah,0EEh
		1103	jmp xop_pcom_instruction
		1104	xop_pcom_uq_instruction:
		1105	mov ah,0EFh
		1106	jmp xop_pcom_instruction
		1107	xop_pcom_uw_instruction:
		1108	mov ah,0EDh
		1109	xop_pcom_instruction:
		1110	mov byte [value],al
		1111	mov [mmx_size],16
		1112	mov [base_code],ah
		1113	mov [xop_opcode_map],8
		1114	jmp avx_common
		1115	vpcmov_instruction:
		1116	or [vex_required],1
		1117	mov [immediate_size],-2
		1118	mov byte [value],0
		1119	mov [mmx_size],0
		1120	mov [base_code],al
		1121	mov [xop_opcode_map],8
		1122	jmp avx_common
		1123	xop_shift_instruction:
		1124	mov [base_code],al
		1125	or [vex_required],1
		1126	mov [xop_opcode_map],9
		1127	call take_avx_register
		1128	cmp ah,16
		1129	jne invalid_operand
		1130	mov [postbyte_register],al
		1131	lods byte [esi]
		1132	cmp al,','
		1133	jne invalid_operand
		1134	lods byte [esi]
		1135	call get_size_operator
		1136	cmp al,'['
		1137	je xop_shift_reg_mem
		1138	cmp al,10h
		1139	jne invalid_operand
		1140	lods byte [esi]
		1141	call convert_xmm_register
		1142	mov [vex_register],al
		1143	lods byte [esi]
		1144	cmp al,','
		1145	jne invalid_operand
		1146	push esi
		1147	xor cl,cl
		1148	xchg cl,[operand_size]
		1149	lods byte [esi]
		1150	call get_size_operator
		1151	pop esi
		1152	xchg cl,[operand_size]
		1153	cmp al,'['
		1154	je xop_shift_reg_reg_mem
		1155	cmp al,10h
		1156	jne xop_shift_reg_reg_imm
		1157	call take_avx_register
		1158	mov bl,al
		1159	xchg bl,[vex_register]
		1160	jmp nomem_instruction_ready
		1161	xop_shift_reg_reg_mem:
		1162	or [rex_prefix],8
		1163	lods byte [esi]
		1164	call get_size_operator
		1165	call get_address
		1166	jmp instruction_ready
		1167	xop_shift_reg_reg_imm:
		1168	xor bl,bl
		1169	xchg bl,[vex_register]
		1170	cmp [base_code],94h
		1171	jae invalid_operand
		1172	add [base_code],30h
		1173	mov [xop_opcode_map],8
		1174	dec esi
		1175	jmp mmx_nomem_imm8
		1176	xop_shift_reg_mem:
		1177	call get_address
		1178	lods byte [esi]
		1179	cmp al,','
		1180	jne invalid_operand
		1181	push esi
		1182	xor cl,cl
		1183	xchg cl,[operand_size]
		1184	lods byte [esi]
		1185	call get_size_operator
		1186	pop esi
		1187	xchg cl,[operand_size]
		1188	cmp al,10h
		1189	jne xop_shift_reg_mem_imm
		1190	call take_avx_register
		1191	mov [vex_register],al
		1192	jmp instruction_ready
		1193	xop_shift_reg_mem_imm:
		1194	cmp [base_code],94h
		1195	jae invalid_operand
		1196	add [base_code],30h
		1197	mov [xop_opcode_map],8
		1198	dec esi
		1199	jmp mmx_imm8
		1200
		1201
		1202	mov [immediate_size],-2
		1203	mov byte [value],al
		1204	mov al,49h
		1205	jmp vpermil2_instruction_setup
		1206	vpermil_2ps_instruction:
		1207	mov [immediate_size],-2
		1208	mov byte [value],al
		1209	mov al,48h
		1210	jmp vpermil2_instruction_setup
		1211	vpermil2_instruction:
		1212	mov [immediate_size],-3
		1213	mov byte [value],0
		1214	vpermil2_instruction_setup:
		1215	mov [base_code],0Fh
		1216	mov [supplemental_code],al
		1217	mov al,3Ah
		1218	mov [mmx_size],0
		1219	jmp avx_instruction
		1220
		1221
		1222	lods byte [esi]
		1223	call get_size_operator
		1224	cmp al,10h
		1225	jne invalid_operand
		1226	lods byte [esi]
		1227	convert_avx_register:
		1228	mov ah,al
		1229	and al,0Fh
		1230	and ah,0F0h
		1231	sub ah,0B0h
		1232	jbe invalid_operand
		1233	cmp ah,32
		1234	ja invalid_operand
		1235	cmp al,8
		1236	jb match_register_size
		1237	cmp [code_type],64
		1238	jne invalid_operand
		1239	jmp match_register_size
		1240	store_vex_instruction_code:
		1241	mov al,[base_code]
		1242	cmp al,0Fh
		1243	jne store_xop_instruction_code
		1244	mov ah,[extended_code]
		1245	cmp ah,38h
		1246	je store_vex_0f38_instruction_code
		1247	cmp ah,3Ah
		1248	je store_vex_0f3a_instruction_code
		1249	test [rex_prefix],1011b
		1250	jnz store_vex_0f_instruction_code
		1251	mov [edi+2],ah
		1252	mov byte [edi],0C5h
		1253	mov al,[vex_register]
		1254	not al
		1255	shl al,3
		1256	mov ah,[rex_prefix]
		1257	shl ah,5
		1258	and ah,80h
		1259	xor al,ah
		1260	call get_vex_lpp_bits
		1261	mov [edi+1],al
		1262	call check_vex
		1263	add edi,3
		1264	ret
		1265	get_vex_lpp_bits:
		1266	cmp [operand_size],32
		1267	jne vex_l_bit_ok
		1268	or al,100b
		1269	vex_l_bit_ok:
		1270	mov ah,[opcode_prefix]
		1271	cmp ah,66h
		1272	je vex_66
		1273	cmp ah,0F3h
		1274	je vex_f3
		1275	cmp ah,0F2h
		1276	je vex_f2
		1277	test ah,ah
		1278	jnz prefix_conflict
		1279	ret
		1280	vex_f2:
		1281	or al,11b
		1282	ret
		1283	vex_f3:
		1284	or al,10b
		1285	ret
		1286	vex_66:
		1287	or al,1
		1288	ret
		1289	store_vex_0f38_instruction_code:
		1290	mov al,11100010b
		1291	mov ah,[supplemental_code]
		1292	jmp make_c4_vex
		1293	store_vex_0f3a_instruction_code:
		1294	mov al,11100011b
		1295	mov ah,[supplemental_code]
		1296	jmp make_c4_vex
		1297	store_vex_0f_instruction_code:
		1298	mov al,11100001b
		1299	make_c4_vex:
		1300	mov [edi+3],ah
		1301	mov byte [edi],0C4h
		1302	mov ah,[rex_prefix]
		1303	shl ah,5
		1304	xor al,ah
		1305	mov [edi+1],al
		1306	call check_vex
		1307	mov al,[vex_register]
		1308	xor al,1111b
		1309	shl al,3
		1310	mov ah,[rex_prefix]
		1311	shl ah,4
		1312	and ah,80h
		1313	or al,ah
		1314	call get_vex_lpp_bits
		1315	mov [edi+2],al
		1316	add edi,4
		1317	ret
		1318	check_vex:
		1319	cmp [code_type],64
		1320	je vex_ok
		1321	not al
		1322	test al,11000000b
		1323	jnz invalid_operand
		1324	test [rex_prefix],40h
		1325	jnz invalid_operand
		1326	vex_ok:
		1327	ret
		1328	store_xop_instruction_code:
		1329	mov [edi+3],al
		1330	mov byte [edi],8Fh
		1331	mov al,[xop_opcode_map]
		1332	mov ah,[rex_prefix]
		1333	test ah,40h
		1334	jz xop_ok
		1335	cmp [code_type],64
		1336	jne invalid_operand
		1337	xop_ok:
		1338	not ah
		1339	shl ah,5
		1340	xor al,ah
		1341	mov [edi+1],al
		1342	mov al,[vex_register]
		1343	xor al,1111b
		1344	shl al,3
		1345	mov ah,[rex_prefix]
		1346	shl ah,4
		1347	and ah,80h
		1348	or al,ah
		1349	call get_vex_lpp_bits
		1350	mov [edi+2],al
		1351	add edi,4
		1352	ret
		1353

Subversion Repositories Kolibri OS

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