Debian Codegraph @

check/public-tests/instructions_i_t.c

raw
1 /*
2 * FCML - Free Code Manipulation Library.
3 * Copyright (C) 2010-2020 Slawomir Wojtasiak
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20 #include <fcml_assembler.h>
21 #include "instructions_i_t.h"
22 #include "instructions_base_t.h"
23
24 fcml_bool fcml_tf_instructions_i_suite_init(void) {
25 return FCML_TRUE;
26 }
27
28 fcml_bool fcml_tf_instructions_i_suite_cleanup(void) {
29 return FCML_TRUE;
30 }
31
32 void fcml_tf_instruction_IDIV(void) {
33
34 FCML_I32( "idiv ax,byte ptr [ebx]", 0xF6, 0x3B );
35 FCML_I32( "idiv ax,byte ptr [ebx]", 0x66, 0xF6, 0x3B );
36 FCML_I64( "idiv ax,sil", 0x40, 0xF6, 0xFE );
37 FCML_I64( "idiv ax,dh", 0xF6, 0xFE );
38
39 FCML_I32( "idiv eax,dword ptr [ebx]", 0xF7, 0x3B );
40 FCML_I32( "idiv ax,word ptr [ebx]", 0x66, 0xF7, 0x3B );
41 FCML_I64( "idiv rax,rsi", 0x48, 0xF7, 0xFE );
42 FCML_I64( "idiv eax,esi", 0xF7, 0xFE );
43
44 FCML_A64( "idivb (%rbx),%ax", 0xf6, 0x3b );
45 FCML_A64( "idivb %dh,%ax", 0xf6, 0xfe );
46 FCML_A64( "idivl (%rbx),%eax", 0xf7, 0x3b );
47 FCML_A64( "idivw (%rbx),%ax", 0x66, 0xf7, 0x3b );
48 FCML_A64( "idivl %esi,%eax", 0xf7, 0xfe );
49 FCML_A64_A( "idiv %esi,%eax", 0xf7, 0xfe );
50 FCML_A64( "idivq %rsi,%rax", 0x48, 0xf7, 0xfe );
51 FCML_A64_A( "idiv %rsi,%rax", 0x48, 0xf7, 0xfe );
52 }
53
54 void fcml_tf_instruction_IMUL(void) {
55
56 FCML_I32( "imul byte ptr [eax+00000020h]", 0xF6, 0x68, 0x20 );
57 FCML_I32( "imul byte ptr [eax+00000020h]", 0x66, 0xF6, 0x68, 0x20 );
58 FCML_I64( "imul byte ptr [rax+0000000000000020h]", 0xF6, 0x68, 0x20 );
59 FCML_A64( "imulb 0x0000000000000020(%rax)", 0xf6, 0x68, 0x20 );
60
61 FCML_I32( "imul dword ptr [eax+00000020h]", 0xF7, 0x68, 0x20 );
62 FCML_I32( "imul word ptr [eax+00000020h]", 0x66, 0xF7, 0x68, 0x20 );
63 FCML_I64( "imul dword ptr [rax+0000000000000020h]", 0xF7, 0x68, 0x20 );
64 FCML_I64( "imul word ptr [rax+0000000000000020h]", 0x66, 0xF7, 0x68, 0x20 );
65 FCML_I64( "imul qword ptr [rax+0000000000000020h]", 0x48, 0xF7, 0x68, 0x20 );
66 FCML_A64( "imull 0x0000000000000020(%rax)", 0xf7, 0x68, 0x20 );
67 FCML_A64( "imulw 0x0000000000000020(%rax)", 0x66, 0xf7, 0x68, 0x20 );
68 FCML_A64( "imulq 0x0000000000000020(%rax)", 0x48, 0xf7, 0x68, 0x20 );
69
70 FCML_I32( "imul ebp,dword ptr [eax+00000020h]", 0x0F, 0xAF, 0x68, 0x20 );
71 FCML_I32( "imul bp,word ptr [eax+00000020h]", 0x66, 0x0F, 0xAF, 0x68, 0x20 );
72 FCML_I64( "imul ebp,dword ptr [rax+0000000000000020h]", 0x0F, 0xAF, 0x68, 0x20 );
73 FCML_I64( "imul bp,word ptr [rax+0000000000000020h]", 0x66, 0x0F, 0xAF, 0x68, 0x20 );
74 FCML_I64( "imul rbp,qword ptr [rax+0000000000000020h]", 0x48, 0x0F, 0xAF, 0x68, 0x20 );
75 FCML_A64( "imull 0x0000000000000020(%rax),%ebp", 0x0f, 0xaf, 0x68, 0x20 );
76 FCML_A64( "imulw 0x0000000000000020(%rax),%bp", 0x66, 0x0f, 0xaf, 0x68, 0x20 );
77 FCML_A64( "imulq 0x0000000000000020(%rax),%rbp", 0x48, 0x0f, 0xaf, 0x68, 0x20 );
78 FCML_A64_A( "imul 0x0000000000000020(%rax),%ebp", 0x0f, 0xaf, 0x68, 0x20 );
79 FCML_A64_A( "imul 0x0000000000000020(%rax),%bp", 0x66, 0x0f, 0xaf, 0x68, 0x20 );
80 FCML_A64_A( "imul 0x0000000000000020(%rax),%rbp", 0x48, 0x0f, 0xaf, 0x68, 0x20 );
81
82 FCML_I32_M( "imul ebp,dword ptr [eax+00000020h],00000040h", 2, FCML_MI( 0x6B, 0x68, 0x20, 0x40 ), FCML_MI( 0x69, 0x68, 0x20, 0x40, 0x00, 0x00, 0x00 ) );
83 FCML_I32_M( "imul bp,word ptr [eax+00000020h],0040h", 2, FCML_MI( 0x66, 0x6B, 0x68, 0x20, 0x40 ), FCML_MI( 0x66, 0x69, 0x68, 0x20, 0x40, 0x00 ) );
84 FCML_I64_M( "imul ebp,dword ptr [rax+0000000000000020h],00000040h", 2, FCML_MI( 0x6B, 0x68, 0x20, 0x40 ), FCML_MI( 0x69, 0x68, 0x20, 0x40, 0x00, 0x00, 0x00 ) );
85 FCML_I64_M( "imul bp,word ptr [rax+0000000000000020h],0040h", 2, FCML_MI( 0x66, 0x6B, 0x68, 0x20, 0x40 ), FCML_MI( 0x66, 0x69, 0x68, 0x20, 0x40, 0x00 ) );
86 FCML_I64_M( "imul rbp,qword ptr [rax+0000000000000020h],0000000000000040h", 2, FCML_MI( 0x48, 0x6B, 0x68, 0x20, 0x40 ), FCML_MI( 0x48, 0x69, 0x68, 0x20, 0x40, 0x00, 0x00, 0x00 ) );
87 FCML_A64_M( "imulq $0x0000000000000040,0x0000000000000020(%rax),%rbp", 2, FCML_MI( 0x48, 0x6B, 0x68, 0x20, 0x40 ), FCML_MI( 0x48, 0x69, 0x68, 0x20, 0x40, 0x00, 0x00, 0x00 ) );
88
89 FCML_I32( "imul ebp,dword ptr [eax+00000020h],70605040h", 0x69, 0x68, 0x20, 0x40, 0x50, 0x60, 0x70 );
90 FCML_I32( "imul bp,word ptr [eax+00000020h],5040h", 0x66, 0x69, 0x68, 0x20, 0x40, 0x50 );
91 FCML_I64( "imul ebp,dword ptr [rax+0000000000000020h],70605040h", 0x69, 0x68, 0x20, 0x40, 0x50, 0x60, 0x70 );
92 FCML_I64( "imul bp,word ptr [rax+0000000000000020h],5040h", 0x66, 0x69, 0x68, 0x20, 0x40, 0x50 );
93 FCML_A64( "imulw $0x5040,0x0000000000000020(%rax),%bp", 0x66, 0x69, 0x68, 0x20, 0x40, 0x50 );
94 FCML_A64_A( "imul $0x5040,0x0000000000000020(%rax),%bp", 0x66, 0x69, 0x68, 0x20, 0x40, 0x50 );
95 /* In this case value is not sign extended to 64 bits, so can not be treated as signed!
96 */
97 FCML_I64_A_FAILED( "imul rbp,qword ptr [rax+0000000000000020h],0ffffffffff605040h", 0x48, 0x69, 0x68, 0x20, 0x40, 0x50, 0x60, 0xFF );
98 FCML_I64_D( "imul rbp,qword ptr [rax+0000000000000020h],0ff605040h", 0x48, 0x69, 0x68, 0x20, 0x40, 0x50, 0x60, 0xFF );
99 FCML_A64( "imulq $0xff605040,0x0000000000000020(%rax),%rbp", 0x48, 0x69, 0x68, 0x20, 0x40, 0x50, 0x60, 0xff );
100 }
101
102 void fcml_tf_instruction_IN(void) {
103
104 FCML_I32( "in al,20h", 0xE4, 0x20 );
105 FCML_I64( "in al,20h", 0x66, 0xE4, 0x20 );
106 FCML_I32( "in eax,20h", 0xE5, 0x20 );
107 FCML_I32( "in ax,20h", 0x66, 0xE5, 0x20 );
108 FCML_I64_D( "in eax,20h", 0x48, 0xE5, 0x20 );
109
110 FCML_I32( "in al,dx", 0xEC );
111 FCML_I64( "in al,dx", 0x66, 0xEC );
112 FCML_I32( "in eax,dx", 0xED );
113 FCML_I32( "in ax,dx", 0x66, 0xED );
114 FCML_I64_D( "in eax,dx", 0x48, 0xED );
115
116 FCML_A64( "in $0x20,%al", 0xe4, 0x20 );
117 FCML_A64( "in $0x20,%eax", 0xe5, 0x20 );
118 FCML_A64( "in $0x20,%ax", 0x66, 0xe5, 0x20 );
119 /* TODO: Gas also supports following form: "in (%dx),%eax" so it should be supported in the future.
120 */
121 FCML_A64( "in %dx,%al", 0xec );
122 }
123
124 void fcml_tf_instruction_INC(void) {
125
126 FCML_I32_M( "inc eax", 2, FCML_MI( 0x40 ), FCML_MI( 0xff, 0xc0 ) );
127 FCML_I32_M( "inc ax", 2, FCML_MI( 0x66, 0x40 ), FCML_MI( 0x66, 0xff, 0xc0 ) );
128 FCML_I32_M( "inc ecx", 2, FCML_MI( 0x41 ), FCML_MI( 0xff, 0xc1 ) );
129 FCML_I32_M( "inc cx", 2, FCML_MI( 0x66, 0x41 ), FCML_MI( 0x66, 0xff, 0xc1 ) );
130 FCML_I32( "lock inc dword ptr [ebx]", 0xF0, 0xFF, 0x03 );
131 FCML_I32( "xacquire lock inc dword ptr [ebx]", 0xF2, 0xF0, 0xFF, 0x03 );
132 FCML_I32( "xrelease lock inc dword ptr [ebx]", 0xF3, 0xF0, 0xFF, 0x03 );
133 FCML_I32( "inc word ptr [ebx]", 0x66, 0xFF, 0x03 );
134 FCML_I64( "inc dword ptr [rbx]", 0xFF, 0x03 );
135 FCML_I64( "inc qword ptr [rbx]", 0x48, 0xFF, 0x03 );
136 FCML_I64_D( "inc word ptr [rbx]", 0x66, 0x40, 0xFF, 0x03 );
137 FCML_I64( "inc r12", 0x49, 0xFF, 0xC4 );
138
139 FCML_A64( "incw %ax", 0x66, 0xff, 0xc0 );
140 FCML_A64_A( "inc %ax", 0x66, 0xff, 0xc0 );
141 FCML_A64( "incl (%rax)", 0xff, 0x00 );
142 FCML_A64( "incw (%rax)", 0x66, 0xff, 0x00 );
143 FCML_A64( "incq (%rax)", 0x48, 0xff, 0x00 );
144
145 FCML_I32( "lock inc byte ptr [eax]", 0xF0, 0xFE, 0x00 );
146 FCML_I32( "xacquire lock inc byte ptr [eax]", 0xF2, 0xF0, 0xFE, 0x00 );
147 FCML_I32( "xrelease lock inc byte ptr [eax]", 0xF3, 0xF0, 0xFE, 0x00 );
148 FCML_I64( "inc byte ptr [rax]", 0xFE, 0x00 );
149 FCML_I64_D( "inc byte ptr [rax]", 0x48, 0xFE, 0x00 );
150 FCML_I64( "inc spl", 0x40, 0xFE, 0xC4 );
151
152 FCML_A64( "lock incb (%rax)", 0xf0, 0xfe, 0x00 );
153 FCML_A64( "incb (%rax)", 0xfe, 0x00 );
154 FCML_A64( "incb %spl", 0x40, 0xfe, 0xc4 );
155 FCML_A64_A( "inc %spl", 0x40, 0xfe, 0xc4 );
156
157 FCML_I32_M( "inc eax", 2, FCML_MI( 0x40 ), FCML_MI( 0xff, 0xc0 ) );
158 FCML_I32_M( "inc ecx", 2, FCML_MI( 0x41 ), FCML_MI( 0xff, 0xc1 ) );
159 FCML_I32_M( "inc dx", 2, FCML_MI( 0x66, 0x42 ), FCML_MI( 0x66, 0xff, 0xc2 ) );
160
161 FCML_A32_M( "inc %eax", 2, FCML_MI( 0x40 ), FCML_MI( 0xff, 0xc0 ) );
162 FCML_A32_M( "inc %ecx", 2, FCML_MI( 0x41 ), FCML_MI( 0xff, 0xc1 ) );
163 FCML_A32_M( "inc %dx", 2, FCML_MI( 0x66, 0x42 ), FCML_MI( 0x66, 0xff, 0xc2 ) );
164 }
165
166 void fcml_tf_instruction_INS(void) {
167
168 FCML_I32( "rep ins byte ptr [edi],dx", 0xF3, 0x6c );
169 FCML_I64( "ins byte ptr [rdi],dx", 0x6c );
170 FCML_I64( "ins byte ptr [edi],dx", 0x67, 0x6c );
171
172 FCML_I32( "rep ins dword ptr [edi],dx", 0xF3, 0x6D );
173 FCML_I64( "ins dword ptr [rdi],dx", 0x6D );
174 FCML_I64( "ins dword ptr [edi],dx", 0x67, 0x6D );
175 FCML_I64( "ins word ptr [edi],dx", 0x66, 0x67, 0x6D );
176 FCML_I64_D( "ins dword ptr [rdi],dx", 0x48, 0x6D );
177 FCML_I32_A( "insb", 0x6c );
178 FCML_I32_A( "insw", 0x66, 0x6D );
179 FCML_I32_A( "insd", 0x6D );
180
181 FCML_A64( "insb %dx,(%rdi)", 0x6c );
182 FCML_A64( "insb %dx,(%edi)", 0x67, 0x6c );
183 FCML_A64( "insl %dx,(%rdi)", 0x6d );
184 FCML_A64( "insl %dx,(%edi)", 0x67, 0x6d );
185 FCML_A64( "insw %dx,(%edi)", 0x66, 0x67, 0x6d );
186 }
187
188 void fcml_tf_instruction_INSERTPS(void) {
189 FCML_I32( "insertps xmm4,dword ptr [eax],40h", 0x66, 0x0F, 0x3A, 0x21, 0x20, 0x40 );
190 FCML_I64( "insertps xmm4,dword ptr [rax],40h", 0x66, 0x0F, 0x3A, 0x21, 0x20, 0x40 );
191 FCML_A64( "insertps $0x40,(%rax),%xmm4", 0x66, 0x0f, 0x3a, 0x21, 0x20, 0x40 );
192
193 FCML_I64_M("vinsertps xmm8,xmm14,dword ptr [r8],20h", 2, FCML_MI(0x62, 0x53, 0x0d, 0x08, 0x21, 0x00, 0x20), FCML_MI(0xc4, 0x43, 0x09, 0x21, 0x00, 0x20));
194 FCML_I32_M("vinsertps xmm0,xmm6,dword ptr [eax],20h", 2, FCML_MI(0x62, 0xf3, 0x4d, 0x08, 0x21, 0x00, 0x20), FCML_MI(0xc4, 0xe3, 0x49, 0x21, 0x00, 0x20));
195 FCML_I32_M("vinsertps xmm0,xmm6,xmm0,20h", 2, FCML_MI(0x62, 0xf3, 0x4d, 0x08, 0x21, 0xc0, 0x20), FCML_MI(0xc4, 0xe3, 0x49, 0x21, 0xc0, 0x20));
196 FCML_A64_M("vinsertps $0x20,(%r8),%xmm14,%xmm8", 2, FCML_MI(0x62, 0x53, 0x0d, 0x08, 0x21, 0x00, 0x20), FCML_MI(0xc4, 0x43, 0x09, 0x21, 0x00, 0x20));
197 }
198
199 void fcml_tf_instruction_INSERTQ(void) {
200
201 FCML_I32( "insertq xmm3,xmm2,01h,02h", 0xF2, 0x0F, 0x78, 0xDA, 0x01, 0x02 );
202 FCML_I64( "insertq xmm3,xmm2,01h,02h", 0xF2, 0x0F, 0x78, 0xDA, 0x01, 0x02 );
203
204 FCML_I32( "insertq xmm3,xmm2", 0xF2, 0x0F, 0x79, 0xDA );
205 FCML_I64( "insertq xmm3,xmm2", 0xF2, 0x0F, 0x79, 0xDA );
206
207 FCML_A64( "insertq $0x02,$0x01,%xmm2,%xmm3", 0xf2, 0x0f, 0x78, 0xda, 0x01, 0x02 );
208 FCML_A64( "insertq %xmm2,%xmm3", 0xf2, 0x0f, 0x79, 0xda );
209 }
210
211 void fcml_tf_instruction_INT(void) {
212 FCML_I3264( "int3", 0xCC );
213 FCML_I3264( "int 20h", 0xcd, 0x20 );
214 FCML_I32( "into", 0xCE );
215 FCML_I64_FAILED( "into", 0xCE );
216
217 FCML_A64( "int3", 0xcc );
218 FCML_A64( "int $0x20", 0xcd, 0x20 );
219 FCML_A32( "into", 0xCE );
220 }
221
222 void fcml_tf_instruction_INVD(void) {
223 FCML_I3264( "invd", 0x0F, 0x08 );
224 }
225
226 void fcml_tf_instruction_INVLPG(void) {
227 FCML_I32( "invlpg [eax+00000020h]", 0x0F, 0x01, 0x78, 0x20 );
228 FCML_I64( "invlpg [rax+0000000000000020h]", 0x0F, 0x01, 0x78, 0x20 );
229
230 FCML_A64( "invlpg 0x0000000000000020(%rax)", 0x0f, 0x01, 0x78, 0x20 );
231 }
232
233 void fcml_tf_instruction_INVLPGA(void) {
234
235 FCML_I32( "invlpga eax,ecx", 0x0F, 0x01, 0xDF );
236 FCML_I32( "invlpga ax,ecx", 0x67, 0x0F, 0x01, 0xDF );
237 FCML_I64( "invlpga rax,ecx", 0x0F, 0x01, 0xDF );
238 FCML_I64( "invlpga eax,ecx", 0x67, 0x0F, 0x01, 0xDF );
239
240 FCML_A64( "invlpga %ecx,%rax", 0x0f, 0x01, 0xdf );
241 FCML_A64_A( "invlpga", 0x0f, 0x01, 0xdf );
242 }
243
244 void fcml_tf_instruction_INVPCID(void) {
245 FCML_I32( "invpcid edx,oword ptr [eax]", 0x66, 0x0F, 0x38, 0x82, 0x10 );
246 FCML_I64( "invpcid rdx,oword ptr [rax]", 0x66, 0x0F, 0x38, 0x82, 0x10 );
247
248 FCML_A64( "invpcid (%rax),%rdx", 0x66, 0x0f, 0x38, 0x82, 0x10 );
249 FCML_A64( "invpcid (%rax),%rdx", 0x66, 0x0f, 0x38, 0x82, 0x10 );
250 }
251
252 void fcml_tf_instruction_IRET(void) {
253 FCML_I32( "iretd", 0xCF );
254 FCML_I32( "iret", 0x66, 0xCF );
255 FCML_I64( "iretd", 0xCF );
256 FCML_I64( "iret", 0x66, 0xCF );
257 FCML_I64( "iretq", 0x48, 0xCF );
258
259 FCML_A64( "iret", 0xcf );
260 FCML_A64( "iretw", 0x66, 0xcf );
261 FCML_A64( "iretq", 0x48, 0xcf );
262 }
263
264 void fcml_tf_instruction_INVEPT(void) {
265 FCML_I32( "invept esp,oword ptr [eax]", 0x66, 0x0F, 0x38, 0x80, 0x20 );
266 FCML_I64( "invept rsp,oword ptr [rax]", 0x66, 0x0F, 0x38, 0x80, 0x20 );
267 FCML_I32_A( "invept esp,[eax]", 0x66, 0x0F, 0x38, 0x80, 0x20 );
268 FCML_I64_A( "invept rsp,[rax]", 0x66, 0x0F, 0x38, 0x80, 0x20 );
269
270 FCML_A64( "invept (%rax),%rsp", 0x66, 0x0f, 0x38, 0x80, 0x20 );
271 }
272
273 void fcml_tf_instruction_INVVPID(void) {
274 FCML_I32( "invvpid esp,oword ptr [eax]", 0x66, 0x0F, 0x38, 0x81, 0x20 );
275 FCML_I64( "invvpid rsp,oword ptr [rax]", 0x66, 0x0F, 0x38, 0x81, 0x20 );
276 FCML_I32_A( "invvpid esp,[eax]", 0x66, 0x0F, 0x38, 0x81, 0x20 );
277 FCML_I64_A( "invvpid rsp,[rax]", 0x66, 0x0F, 0x38, 0x81, 0x20 );
278
279 FCML_A64( "invvpid (%rax),%rsp", 0x66, 0x0f, 0x38, 0x81, 0x20 );
280 FCML_A64( "invvpid (%rax),%rsp", 0x66, 0x0f, 0x38, 0x81, 0x20 );
281 }
282
283 fcml_stf_test_case fctl_ti_instructions_i[] = {
284 { "fcml_tf_instruction_IDIV", fcml_tf_instruction_IDIV },
285 { "fcml_tf_instruction_IMUL", fcml_tf_instruction_IMUL },
286 { "fcml_tf_instruction_IN", fcml_tf_instruction_IN },
287 { "fcml_tf_instruction_INC", fcml_tf_instruction_INC },
288 { "fcml_tf_instruction_INS", fcml_tf_instruction_INS },
289 { "fcml_tf_instruction_INSERTPS", fcml_tf_instruction_INSERTPS },
290 { "fcml_tf_instruction_INSERTQ", fcml_tf_instruction_INSERTQ },
291 { "fcml_tf_instruction_INT", fcml_tf_instruction_INT },
292 { "fcml_tf_instruction_INVD", fcml_tf_instruction_INVD },
293 { "fcml_tf_instruction_INVLPG", fcml_tf_instruction_INVLPG },
294 { "fcml_tf_instruction_INVLPGA", fcml_tf_instruction_INVLPGA },
295 { "fcml_tf_instruction_INVPCID", fcml_tf_instruction_INVPCID },
296 { "fcml_tf_instruction_IRET", fcml_tf_instruction_IRET },
297 { "fcml_tf_instruction_INVEPT", fcml_tf_instruction_INVEPT },
298 { "fcml_tf_instruction_INVVPID", fcml_tf_instruction_INVVPID },
299 FCML_STF_NULL_TEST
300 };
301
302 fcml_stf_test_suite fctl_si_instructions_i = {
303 "suite-fctl_ti_instructions_i", fcml_tf_instructions_i_suite_init, fcml_tf_instructions_i_suite_cleanup, fctl_ti_instructions_i
304 };
305
306