1 /* Copyright (C) 2000, 2002 Free Software Foundation
2 * Contributed by Alexandre Oliva <aoliva@redhat.com>
4 * This file is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 /* Generator of tests for insns introduced in AM33 2.0. */
21 #define INSN_REPEAT 11
23 /* See the following file for usage and documentation. */
24 #include "../all/test-gen.c"
26 /* These are the AM33 registers. */
27 const char *am33_regs
[] = {
28 /* These are the canonical names, i.e., those printed by the
30 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
31 "a0", "a1", "a2", "a3", "d0", "d1", "d2", "d3",
32 /* These are aliases that the assembler should also recognize. */
33 "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7",
34 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
37 /* Signed constants of the given sizes. */
38 #define d8(shift) signed_constant( 8, shift, 1)
39 #define d16(shift) signed_constant(16, shift, 1)
40 #define d24(shift) signed_constant(24, shift, 1)
41 #define d32(shift) signed_constant(32, shift, 1)
42 #define u8(shift) unsigned_constant( 8, shift, 1)
43 #define u24(shift) unsigned_constant(24, shift, 1)
44 #define a16(shift) absolute_address(16, shift, 1)
46 /* Emit an AM33 register shifted by these many words. */
47 #define amreg(shift) reg_r (am33_regs, shift, 15, mk_get_bits (5u))
48 #define spreg literal ("sp")
49 #define fcreg literal ("fpcr")
51 /* Emit an AM33-2 FP single-precision register, with the 4 least
52 * significant bits shifted by shiftlow and the most significant bit
53 * shifted by shifthigh. */
55 freg (func_arg
*arg
, insn_data
*data
)
56 #define freg(shiftlow, shifthigh) { freg, { i1: shiftlow, i2: shifthigh } }
58 unsigned val
= get_bits (5u);
60 data
->as_in
= data
->dis_out
= (char*)malloc (3 + ulen (val
, 10));
61 sprintf (data
->as_in
, "fs%u", val
);
63 data
->bits
= ((data
->bits
& 15) << arg
->i1
) | ((data
->bits
>> 4) << arg
->i2
);
68 /* Emit an AM33-2 FP single-precision register in the ``accumulator''
69 * range, with the 2 least significant bits shifted by shiftlow and
70 * the most significant bit shifted by shifthigh. */
72 areg (func_arg
*arg
, insn_data
*data
)
73 #define areg(shiftlow, shifthigh) { areg, { i1: shiftlow, i2: shifthigh } }
75 unsigned val
= get_bits (3u);
77 data
->as_in
= data
->dis_out
= (char*)malloc (4);
78 sprintf (data
->as_in
, "fs%u", val
);
80 data
->bits
= ((data
->bits
& 3) << arg
->i1
) | ((data
->bits
>> 2) << arg
->i2
);
85 /* Emit an AM33-2 FP double-precision register, with the 4 least
86 * significant bits shifted by shiftlow and the most significant bit
87 * shifted by shifthigh. */
89 dreg (func_arg
*arg
, insn_data
*data
)
90 #define dreg(shiftlow, shifthigh) { dreg, { i1: shiftlow, i2: shifthigh } }
92 unsigned val
= 2 * get_bits (4u);
94 data
->as_in
= data
->dis_out
= (char*)malloc (3 + ulen (val
, 10));
95 sprintf (data
->as_in
, "fd%u", val
);
97 data
->bits
= ((data
->bits
& 15) << arg
->i1
) | ((data
->bits
>> 4) << arg
->i2
);
102 /* Emit a signed 8-bit PC-relative offset from the current insn to the
103 * last emitted label. */
105 d8pcoff (func_arg
*arg
, insn_data
*data
)
106 #define d8pcoff(shift) { d8pcoff, { p1: shift } }
108 int diff
= insn_size
- arg
->i1
/8 - 1;
109 int displacement
= current_offset
- last_label_offset
;
110 char *current_address
= malloc (strlen (last_label_name
) + 4
111 + ulen (displacement
, 16) + 1);
113 /* Make sure we're not too far from the target. */
114 if (displacement
> 128)
117 data
->as_in
= strdup (last_label_name
);
119 /* Calculate the address that will be printed by the disassembler as
120 the target of the jump. Since it won't take relocations into
121 account, it will be the insn's own address. */
122 if (current_offset
== last_label_offset
)
123 strcpy (current_address
, last_label_name
);
125 sprintf (current_address
, "%s\\+0x%x", last_label_name
, displacement
);
127 /* Compute the complete label, including the relocation message
128 printed as an additional message. The relocation will point us
129 to the intended target label plus an offset equal to the offset
130 of the displacement within the current insn. We do not account
131 for the case in which this displacement is zero, since it doesn't
132 come up on this platform. */
133 data
->dis_out
= malloc (8 + 2 + strlen (current_address
) + 2
134 + 3 + ulen (current_offset
+ diff
, 16) + 19
135 + strlen (last_label_name
) + 4
136 + ulen (diff
, 16) + 1);
137 sprintf (data
->dis_out
, "0*%x <%s>\n"
138 "\t\t\t%x: R_MN10300_PCREL8\t%s\\+0x%x",
139 current_offset
, current_address
,
140 current_offset
+ diff
, last_label_name
, diff
);
142 free (current_address
);
147 /* Emit a signed 8-bit PC-relative offset from the current insn to the
148 * current section. */
150 d8pcsec (func_arg
*arg
, insn_data
*data
)
151 #define d8pcsec(shift) { d8pcsec, { p1: shift } }
153 int diff
= insn_size
- arg
->i1
/8 - 1;
154 int displacement
= current_offset
- last_label_offset
;
155 char *current_address
= malloc (strlen (last_label_name
) + 4
156 + ulen (displacement
, 16) + 1);
158 /* Make sure we're not too far from the target. */
159 if (displacement
> 128)
162 data
->as_in
= strdup (last_label_name
);
164 /* Calculate the address that will be printed by the disassembler as
165 the target of the jump. Since it won't take relocations into
166 account, it will be the insn's own address. */
168 if (current_offset
== last_label_offset
)
169 strcpy (current_address
, last_label_name
);
171 sprintf (current_address
, "%s\\+0x%x", last_label_name
, displacement
);
174 /* Compute the complete label, including the relocation message
175 printed as an additional message. The relocation will point us
176 to the intended target label plus an offset equal to the offset
177 of the displacement within the current insn. We do not account
178 for the case in which this displacement is zero, since it doesn't
179 come up on this platform. */
180 data
->dis_out
= malloc (8 + 2 + strlen (current_address
) + 2
181 + 3 + ulen (current_offset
+ diff
, 16) + 33);
182 sprintf (data
->dis_out
, "0*%x <%s>\n"
183 "\t\t\t%x: R_MN10300_PCREL8\tcondjmp\\+0x2",
184 current_offset
, current_address
,
185 current_offset
+ diff
);
187 free (current_address
);
192 /* Convenience wrapper to define_insn. */
193 #define def_am_insn(insname, variant, size, word, funcs...) \
194 define_insn(insname ## _ ## variant, \
195 insn_size_bits (insname, size, \
196 ((unsigned long long)word) << 8*(size-2)), \
199 #define am_insn(insname, variant) insn (insname ## _ ## variant)
201 #define def_bit_insn(insname, word) \
202 def_am_insn (insname, i8a16, 5, word, \
203 u8(0), comma, lparen, a16 (8), rparen, tick_random);
204 #define bit_insn(insname) insn (insname ## _ ## i8a16)
206 /* Data cache pre-fetch insns. */
207 def_am_insn (dcpf
, r
, 3, 0xf9a6, lparen
, amreg (4), rparen
);
208 def_am_insn (dcpf
, sp
, 3, 0xf9a7, lparen
, spreg
, rparen
);
209 def_am_insn (dcpf
, rr
, 4, 0xfba6,
210 lparen
, amreg(12), comma
, amreg (8), rparen
, tick_random
);
211 def_am_insn (dcpf
, d8r
, 4, 0xfba7,
212 lparen
, d8 (0), comma
, amreg (12), rparen
, tick_random
);
213 def_am_insn (dcpf
, d24r
, 6, 0xfda7,
214 lparen
, d24(0), comma
, amreg (28), rparen
, tick_random
);
215 def_am_insn (dcpf
, d32r
, 7, 0xfe46,
216 lparen
, d32(0), comma
, amreg (36), rparen
, tick_random
);
218 /* Define the group of data cache pre-fetch insns. */
219 func
*dcpf_insns
[] = {
224 am_insn (dcpf
, d24r
),
225 am_insn (dcpf
, d32r
),
229 /* Bit operations. */
230 def_bit_insn (bset
, 0xfe80);
231 def_bit_insn (bclr
, 0xfe81);
232 def_bit_insn (btst
, 0xfe82);
234 /* Define the group of bit insns. */
235 func
*bit_insns
[] = {
242 /* Define the single-precision FP move insns. */
243 def_am_insn (fmov
, irfs
, 3, 0xf920,
244 lparen
, amreg (4), rparen
, comma
,
245 freg (0, 8), tick_random
);
246 def_am_insn (fmov
, rpfs
, 3, 0xf922,
247 lparen
, amreg (4), plus
, rparen
, comma
,
248 freg (0, 8), tick_random
);
249 def_am_insn (fmov
, spfs
, 3, 0xf924,
250 lparen
, spreg
, rparen
, comma
, freg (0, 8));
251 def_am_insn (fmov
, vrfs
, 3, 0xf926,
252 amreg (4), comma
, freg (0, 8), tick_random
);
253 def_am_insn (fmov
, fsir
, 3, 0xf930,
254 freg (4, 9), comma
, lparen
, amreg (0), rparen
, tick_random
);
255 def_am_insn (fmov
, fsrp
, 3, 0xf931,
256 freg (4, 9), comma
, lparen
, amreg (0), plus
, rparen
, tick_random
);
257 def_am_insn (fmov
, fssp
, 3, 0xf934,
258 freg (4, 9), comma
, lparen
, spreg
, rparen
);
259 def_am_insn (fmov
, fsvr
, 3, 0xf935,
260 freg (4, 9), comma
, amreg (0), tick_random
);
261 def_am_insn (fmov
, fsfs
, 3, 0xf940,
262 freg (4, 9), comma
, freg (0, 8), tick_random
);
263 def_am_insn (fmov
, d8rfs
, 4, 0xfb20,
264 lparen
, d8 (0), comma
, amreg (12), rparen
, comma
,
266 def_am_insn (fmov
, rpi8fs
, 4, 0xfb22,
267 lparen
, amreg (12), plus
, comma
, d8 (0), rparen
, comma
,
269 def_am_insn (fmov
, d8spfs
, 4, 0xfb24,
270 lparen
, u8 (0), comma
, spreg
, rparen
, comma
, freg (8, 16),
272 def_am_insn (fmov
, irrfs
, 4, 0xfb27,
273 lparen
, amreg (12), comma
, amreg (8), rparen
, comma
,
275 def_am_insn (fmov
, fsd8r
, 4, 0xfb30,
276 freg (12, 17), comma
, lparen
, d8 (0), comma
, amreg (8), rparen
);
277 def_am_insn (fmov
, fsrpi8
, 4, 0xfb31,
278 freg (12, 17), comma
,
279 lparen
, amreg (8), plus
, comma
, d8 (0), rparen
);
280 def_am_insn (fmov
, fsd8sp
, 4, 0xfb34,
281 freg (12, 17), comma
,
282 lparen
, u8 (0), comma
, spreg
, rparen
, tick_random
);
283 def_am_insn (fmov
, fsirr
, 4, 0xfb37,
285 lparen
, amreg (12), comma
, amreg (8), rparen
);
286 def_am_insn (fmov
, d24rfs
, 6, 0xfd20,
287 lparen
, d24 (0), comma
, amreg (28), rparen
, comma
, freg (24, 32));
288 def_am_insn (fmov
, rpi24fs
, 6, 0xfd22,
289 lparen
, amreg (28), plus
, comma
, d24 (0), rparen
, comma
,
291 def_am_insn (fmov
, d24spfs
, 6, 0xfd24,
292 lparen
, u24 (0), comma
, spreg
, rparen
, comma
,
293 freg (24, 32), tick_random
);
294 def_am_insn (fmov
, fsd24r
, 6, 0xfd30,
295 freg (28, 33), comma
, lparen
, d24 (0), comma
, amreg (24), rparen
);
296 def_am_insn (fmov
, fsrpi24
, 6, 0xfd31,
297 freg (28, 33), comma
,
298 lparen
, amreg (24), plus
, comma
, d24 (0), rparen
);
299 def_am_insn (fmov
, fsd24sp
, 6, 0xfd34,
300 freg (28, 33), comma
,
301 lparen
, u24 (0), comma
, spreg
, rparen
, tick_random
);
302 def_am_insn (fmov
, d32rfs
, 7, 0xfe20,
303 lparen
, d32 (0), comma
, amreg (36), rparen
, comma
, freg (32, 40));
304 def_am_insn (fmov
, rpi32fs
, 7, 0xfe22,
305 lparen
, amreg (36), plus
, comma
, d32 (0), rparen
, comma
,
307 def_am_insn (fmov
, d32spfs
, 7, 0xfe24,
308 lparen
, d32 (0), comma
, spreg
, rparen
, comma
,
309 freg (32, 40), tick_random
);
310 def_am_insn (fmov
, i32fs
, 7, 0xfe26,
311 d32 (0), comma
, freg (32, 40), tick_random
);
312 def_am_insn (fmov
, fsd32r
, 7, 0xfe30,
313 freg (36, 41), comma
, lparen
, d32 (0), comma
, amreg (32), rparen
);
314 def_am_insn (fmov
, fsrpi32
, 7, 0xfe31,
315 freg (36, 41), comma
,
316 lparen
, amreg (32), plus
, comma
, d32 (0), rparen
);
317 def_am_insn (fmov
, fsd32sp
, 7, 0xfe34,
318 freg (36, 41), comma
,
319 lparen
, d32 (0), comma
, spreg
, rparen
, tick_random
);
321 /* Define the group of single-precision FP move insns. */
322 func
*fmovs_insns
[] = {
323 am_insn (fmov
, irfs
),
324 am_insn (fmov
, rpfs
),
325 am_insn (fmov
, spfs
),
326 am_insn (fmov
, vrfs
),
327 am_insn (fmov
, fsir
),
328 am_insn (fmov
, fsrp
),
329 am_insn (fmov
, fssp
),
330 am_insn (fmov
, fsvr
),
331 am_insn (fmov
, fsfs
),
332 am_insn (fmov
, d8rfs
),
333 am_insn (fmov
, rpi8fs
),
334 am_insn (fmov
, d8spfs
),
335 am_insn (fmov
, irrfs
),
336 am_insn (fmov
, fsd8r
),
337 am_insn (fmov
, fsrpi8
),
338 am_insn (fmov
, fsd8sp
),
339 am_insn (fmov
, fsirr
),
340 am_insn (fmov
, d24rfs
),
341 am_insn (fmov
, rpi24fs
),
342 am_insn (fmov
, d24spfs
),
343 am_insn (fmov
, fsd24r
),
344 am_insn (fmov
, fsrpi24
),
345 am_insn (fmov
, fsd24sp
),
346 am_insn (fmov
, d32rfs
),
347 am_insn (fmov
, rpi32fs
),
348 am_insn (fmov
, d32spfs
),
349 am_insn (fmov
, i32fs
),
350 am_insn (fmov
, fsd32r
),
351 am_insn (fmov
, fsrpi32
),
352 am_insn (fmov
, fsd32sp
),
356 /* Define the double-precision FP move insns. */
357 def_am_insn (fmov
, irfd
, 3, 0xf9a0,
358 lparen
, amreg (4), rparen
, comma
, dreg (0, 8), tick_random
);
359 def_am_insn (fmov
, rpfd
, 3, 0xf9a2,
360 lparen
, amreg (4), plus
, rparen
, comma
, dreg (0, 8), tick_random
);
361 def_am_insn (fmov
, spfd
, 3, 0xf9a4,
362 lparen
, spreg
, rparen
, comma
, dreg (0, 8));
363 def_am_insn (fmov
, fdir
, 3, 0xf9b0,
364 dreg (4, 9), comma
, lparen
, amreg (0), rparen
, tick_random
);
365 def_am_insn (fmov
, fdrp
, 3, 0xf9b1,
366 dreg (4, 9), comma
, lparen
, amreg (0), plus
, rparen
, tick_random
);
367 def_am_insn (fmov
, fdsp
, 3, 0xf9b4,
368 dreg (4, 9), comma
, lparen
, spreg
, rparen
);
369 def_am_insn (fmov
, fdfd
, 3, 0xf9c0,
370 dreg (4, 9), comma
, dreg (0, 8), tick_random
);
371 def_am_insn (fmov
, irrfd
, 4, 0xfb47,
372 lparen
, amreg (12), comma
, amreg (8), rparen
, comma
, dreg (4, 1));
373 def_am_insn (fmov
, fdirr
, 4, 0xfb57,
374 dreg (4, 1), comma
, lparen
, amreg (12), comma
, amreg (8), rparen
);
375 def_am_insn (fmov
, d8rfd
, 4, 0xfba0,
376 lparen
, d8 (0), comma
, amreg (12), rparen
, comma
, dreg (8, 16));
377 def_am_insn (fmov
, rpi8fd
, 4, 0xfba2,
378 lparen
, amreg (12), plus
, comma
, d8 (0), rparen
, comma
,
380 def_am_insn (fmov
, d8spfd
, 4, 0xfba4,
381 lparen
, u8 (0), comma
, spreg
, rparen
, comma
,
382 dreg (8, 16), tick_random
);
383 def_am_insn (fmov
, fdd8r
, 4, 0xfbb0,
384 dreg (12, 17), comma
, lparen
, d8 (0), comma
, amreg (8), rparen
);
385 def_am_insn (fmov
, fdrpi8
, 4, 0xfbb1,
386 dreg (12, 17), comma
,
387 lparen
, amreg (8), plus
, comma
, d8 (0), rparen
);
388 def_am_insn (fmov
, fdi8sp
, 4, 0xfbb4,
389 dreg (12, 17), comma
,
390 lparen
, u8 (0), comma
, spreg
, rparen
, tick_random
);
391 def_am_insn (fmov
, d24rfd
, 6, 0xfda0,
392 lparen
, d24 (0), comma
, amreg (28), rparen
, comma
, dreg (24, 32));
393 def_am_insn (fmov
, rpi24fd
, 6, 0xfda2,
394 lparen
, amreg (28), plus
, comma
, d24 (0), rparen
, comma
,
396 def_am_insn (fmov
, d24spfd
, 6, 0xfda4,
397 lparen
, u24 (0), comma
, spreg
, rparen
, comma
,
398 dreg (24, 32), tick_random
);
399 def_am_insn (fmov
, fdd24r
, 6, 0xfdb0,
400 dreg (28, 33), comma
,
401 lparen
, d24 (0), comma
, amreg (24), rparen
);
402 def_am_insn (fmov
, fdrpi24
, 6, 0xfdb1,
403 dreg (28, 33), comma
,
404 lparen
, amreg (24), plus
, comma
, d24 (0), rparen
);
405 def_am_insn (fmov
, fdd24sp
, 6, 0xfdb4,
406 dreg (28, 33), comma
,
407 lparen
, u24 (0), comma
, spreg
, rparen
, tick_random
);
408 def_am_insn (fmov
, d32rfd
, 7, 0xfe40,
409 lparen
, d32 (0), comma
, amreg (36), rparen
, comma
, dreg (32, 40));
410 def_am_insn (fmov
, rpi32fd
, 7, 0xfe42,
411 lparen
, amreg (36), plus
, comma
, d32 (0), rparen
, comma
,
413 def_am_insn (fmov
, d32spfd
, 7, 0xfe44,
414 lparen
, d32 (0), comma
, spreg
, rparen
, comma
,
415 dreg (32, 40), tick_random
);
416 def_am_insn (fmov
, fdd32r
, 7, 0xfe50,
417 dreg (36, 41), comma
,
418 lparen
, d32 (0), comma
, amreg (32), rparen
);
419 def_am_insn (fmov
, fdrpi32
, 7, 0xfe51,
420 dreg (36, 41), comma
,
421 lparen
, amreg (32), plus
, comma
, d32 (0), rparen
);
422 def_am_insn (fmov
, fdd32sp
, 7, 0xfe54,
423 dreg (36, 41), comma
,
424 lparen
, d32 (0), comma
, spreg
, rparen
, tick_random
);
426 /* Define the group of double-precision FP move insns. */
427 func
*fmovd_insns
[] = {
428 am_insn (fmov
, irfd
),
429 am_insn (fmov
, rpfd
),
430 am_insn (fmov
, spfd
),
431 am_insn (fmov
, fdir
),
432 am_insn (fmov
, fdrp
),
433 am_insn (fmov
, fdsp
),
434 am_insn (fmov
, fdfd
),
435 am_insn (fmov
, irrfd
),
436 am_insn (fmov
, fdirr
),
437 am_insn (fmov
, d8rfd
),
438 am_insn (fmov
, rpi8fd
),
439 am_insn (fmov
, d8spfd
),
440 am_insn (fmov
, fdd8r
),
441 am_insn (fmov
, fdrpi8
),
442 am_insn (fmov
, fdi8sp
),
443 am_insn (fmov
, d24rfd
),
444 am_insn (fmov
, rpi24fd
),
445 am_insn (fmov
, d24spfd
),
446 am_insn (fmov
, fdd24r
),
447 am_insn (fmov
, fdrpi24
),
448 am_insn (fmov
, fdd24sp
),
449 am_insn (fmov
, d32rfd
),
450 am_insn (fmov
, rpi32fd
),
451 am_insn (fmov
, d32spfd
),
452 am_insn (fmov
, fdd32r
),
453 am_insn (fmov
, fdrpi32
),
454 am_insn (fmov
, fdd32sp
),
458 /* Define fmov FPCR insns. */
459 def_am_insn (fmov
, vrfc
, 3, 0xf9b5,
460 amreg (4), comma
, fcreg
);
461 def_am_insn (fmov
, fcvr
, 3, 0xf9b7,
462 fcreg
, comma
, amreg (0));
463 def_am_insn (fmov
, i32fc
, 6, 0xfdb5,
464 d32 (0), comma
, fcreg
);
466 /* Define the group of FPCR move insns. */
467 func
*fmovc_insns
[] = {
468 am_insn (fmov
, vrfc
),
469 am_insn (fmov
, fcvr
),
470 am_insn (fmov
, i32fc
),
474 /* Define single-precision floating-point arithmetic insns. */
475 def_am_insn (fabs
, fs
, 3, 0xf944, freg (0, 8));
476 def_am_insn (fabs
, fsfs
, 4, 0xfb44,
477 freg (12, 3), comma
, freg (4, 1), tick_random
);
478 def_am_insn (fneg
, fs
, 3, 0xf946, freg (0, 8));
479 def_am_insn (fneg
, fsfs
, 4, 0xfb46,
480 freg (12, 3), comma
, freg (4, 1), tick_random
);
481 def_am_insn (frsqrt
, fs
, 3, 0xf950, freg (0, 8));
482 def_am_insn (frsqrt
, fsfs
, 4, 0xfb50,
483 freg (12, 3), comma
, freg (4, 1), tick_random
);
484 def_am_insn (fsqrt
, fs
, 3, 0xf952, freg (0, 8));
485 def_am_insn (fsqrt
, fsfs
, 4, 0xfb54,
486 freg (12, 3), comma
, freg (4, 1), tick_random
);
487 def_am_insn (fcmp
, fsfs
, 3, 0xf954,
488 freg (4, 9), comma
, freg (0, 8), tick_random
);
489 def_am_insn (fcmp
, i32fs
, 7, 0xfe35,
490 d32 (0), comma
, freg (36, 41), tick_random
);
491 def_am_insn (fadd
, fsfs
, 3, 0xf960,
492 freg (4, 9), comma
, freg (0, 8), tick_random
);
493 def_am_insn (fadd
, fsfsfs
, 4, 0xfb60,
494 freg (12, 3), comma
, freg (8, 2), comma
, freg (4, 1));
495 def_am_insn (fadd
, i32fsfs
, 7, 0xfe60,
496 d32 (0), comma
, freg (36, 41), comma
, freg (32, 40));
497 def_am_insn (fsub
, fsfs
, 3, 0xf964,
498 freg (4, 9), comma
, freg (0, 8), tick_random
);
499 def_am_insn (fsub
, fsfsfs
, 4, 0xfb64,
500 freg (12, 3), comma
, freg (8, 2), comma
, freg (4, 1));
501 def_am_insn (fsub
, i32fsfs
, 7, 0xfe64,
502 d32 (0), comma
, freg (36, 41), comma
, freg (32, 40));
503 def_am_insn (fmul
, fsfs
, 3, 0xf970,
504 freg (4, 9), comma
, freg (0, 8), tick_random
);
505 def_am_insn (fmul
, fsfsfs
, 4, 0xfb70,
506 freg (12, 3), comma
, freg (8, 2), comma
, freg (4, 1));
507 def_am_insn (fmul
, i32fsfs
, 7, 0xfe70,
508 d32 (0), comma
, freg (36, 41), comma
, freg (32, 40));
509 def_am_insn (fdiv
, fsfs
, 3, 0xf974,
510 freg (4, 9), comma
, freg (0, 8), tick_random
);
511 def_am_insn (fdiv
, fsfsfs
, 4, 0xfb74,
512 freg (12, 3), comma
, freg (8, 2), comma
, freg (4, 1));
513 def_am_insn (fdiv
, i32fsfs
, 7, 0xfe74,
514 d32 (0), comma
, freg (36, 41), comma
, freg (32, 40));
516 /* Define the group of single-precision floating-point arithmetic insns. */
517 func
*sfparith_insns
[] = {
519 am_insn (fabs
, fsfs
),
521 am_insn (fneg
, fsfs
),
522 am_insn (frsqrt
, fs
),
523 am_insn (frsqrt
, fsfs
),
525 am_insn (fsqrt
, fsfs
),
526 am_insn (fcmp
, fsfs
),
527 am_insn (fcmp
, i32fs
),
528 am_insn (fadd
, fsfs
),
529 am_insn (fadd
, fsfsfs
),
530 am_insn (fadd
, i32fsfs
),
531 am_insn (fsub
, fsfs
),
532 am_insn (fsub
, fsfsfs
),
533 am_insn (fsub
, i32fsfs
),
534 am_insn (fmul
, fsfs
),
535 am_insn (fmul
, fsfsfs
),
536 am_insn (fmul
, i32fsfs
),
537 am_insn (fdiv
, fsfs
),
538 am_insn (fdiv
, fsfsfs
),
539 am_insn (fdiv
, i32fsfs
),
543 /* Define floating-point accumulator arithmetic insns. */
544 def_am_insn (fmadd
, , 4, 0xfb80,
545 freg (12, 3), comma
, freg (8, 2), comma
,
546 freg (4, 1), comma
, areg (16, 0), tick_random
);
547 def_am_insn (fmsub
, , 4, 0xfb84,
548 freg (12, 3), comma
, freg (8, 2), comma
,
549 freg (4, 1), comma
, areg (16, 0), tick_random
);
550 def_am_insn (fnmadd
, , 4, 0xfb90,
551 freg (12, 3), comma
, freg (8, 2), comma
,
552 freg (4, 1), comma
, areg (16, 0), tick_random
);
553 def_am_insn (fnmsub
, , 4, 0xfb94,
554 freg (12, 3), comma
, freg (8, 2), comma
,
555 freg (4, 1), comma
, areg (16, 0), tick_random
);
557 /* Define the group of floating-point accumulator arithmetic insns. */
558 func
*fpacc_insns
[] = {
566 /* Define double-precision floating-point arithmetic insns. */
567 def_am_insn (fabs
, fd
, 3, 0xf9c4, dreg (0, 8));
568 def_am_insn (fabs
, fdfd
, 4, 0xfbc4,
569 dreg (12, 3), comma
, dreg (4, 1), tick_random
);
570 def_am_insn (fneg
, fd
, 3, 0xf9c6, dreg (0, 8));
571 def_am_insn (fneg
, fdfd
, 4, 0xfbc6,
572 dreg (12, 3), comma
, dreg (4, 1), tick_random
);
573 def_am_insn (frsqrt
, fd
, 3, 0xf9d0, dreg (0, 8));
574 def_am_insn (frsqrt
, fdfd
, 4, 0xfbd0,
575 dreg (12, 3), comma
, dreg (4, 1), tick_random
);
576 def_am_insn (fsqrt
, fd
, 3, 0xf9d2, dreg (0, 8));
577 def_am_insn (fsqrt
, fdfd
, 4, 0xfbd4,
578 dreg (12, 3), comma
, dreg (4, 1), tick_random
);
579 def_am_insn (fcmp
, fdfd
, 3, 0xf9d4,
580 dreg (4, 9), comma
, dreg (0, 8), tick_random
);
581 def_am_insn (fadd
, fdfd
, 3, 0xf9e0,
582 dreg (4, 9), comma
, dreg (0, 8), tick_random
);
583 def_am_insn (fadd
, fdfdfd
, 4, 0xfbe0,
584 dreg (12, 3), comma
, dreg (8, 2), comma
, dreg (4, 1));
585 def_am_insn (fsub
, fdfd
, 3, 0xf9e4,
586 dreg (4, 9), comma
, dreg (0, 8), tick_random
);
587 def_am_insn (fsub
, fdfdfd
, 4, 0xfbe4,
588 dreg (12, 3), comma
, dreg (8, 2), comma
, dreg (4, 1));
589 def_am_insn (fmul
, fdfd
, 3, 0xf9f0,
590 dreg (4, 9), comma
, dreg (0, 8), tick_random
);
591 def_am_insn (fmul
, fdfdfd
, 4, 0xfbf0,
592 dreg (12, 3), comma
, dreg (8, 2), comma
, dreg (4, 1));
593 def_am_insn (fdiv
, fdfd
, 3, 0xf9f4,
594 dreg (4, 9), comma
, dreg (0, 8), tick_random
);
595 def_am_insn (fdiv
, fdfdfd
, 4, 0xfbf4,
596 dreg (12, 3), comma
, dreg (8, 2), comma
, dreg (4, 1));
598 /* Define the group of double-precision floating-point arithmetic insns. */
599 func
*dfparith_insns
[] = {
601 am_insn (fabs
, fdfd
),
603 am_insn (fneg
, fdfd
),
604 am_insn (frsqrt
, fd
),
605 am_insn (frsqrt
, fdfd
),
607 am_insn (fsqrt
, fdfd
),
608 am_insn (fcmp
, fdfd
),
609 am_insn (fadd
, fdfd
),
610 am_insn (fadd
, fdfdfd
),
611 am_insn (fsub
, fdfd
),
612 am_insn (fsub
, fdfdfd
),
613 am_insn (fmul
, fdfd
),
614 am_insn (fmul
, fdfdfd
),
615 am_insn (fdiv
, fdfd
),
616 am_insn (fdiv
, fdfdfd
),
620 /* Define floating-point conversion insns. */
621 def_am_insn (ftoi
, fsfs
, 4, 0xfb40,
622 freg (12, 3), comma
, freg (4, 1), tick_random
);
623 def_am_insn (itof
, fsfs
, 4, 0xfb42,
624 freg (12, 3), comma
, freg (4, 1), tick_random
);
625 def_am_insn (ftod
, fsfd
, 4, 0xfb52,
626 freg (12, 3), comma
, dreg (4, 1), tick_random
);
627 def_am_insn (dtof
, fdfs
, 4, 0xfb56,
628 dreg (12, 3), comma
, freg (4, 1), tick_random
);
630 /* Define the group of floating-point conversion insns. */
631 func
*fpconv_insns
[] = {
632 am_insn (ftoi
, fsfs
),
633 am_insn (itof
, fsfs
),
634 am_insn (ftod
, fsfd
),
635 am_insn (dtof
, fdfs
),
639 /* Define conditional jump insns. */
640 def_am_insn (fbeq
, , 3, 0xf8d0, d8pcsec (0));
641 def_am_insn (fbne
, , 3, 0xf8d1, d8pcsec (0));
642 def_am_insn (fbgt
, , 3, 0xf8d2, d8pcsec (0));
643 def_am_insn (fbge
, , 3, 0xf8d3, d8pcsec (0));
644 def_am_insn (fblt
, , 3, 0xf8d4, d8pcsec (0));
645 def_am_insn (fble
, , 3, 0xf8d5, d8pcsec (0));
646 def_am_insn (fbuo
, , 3, 0xf8d6, d8pcsec (0));
647 def_am_insn (fblg
, , 3, 0xf8d7, d8pcsec (0));
648 def_am_insn (fbleg
,, 3, 0xf8d8, d8pcsec (0));
649 def_am_insn (fbug
, , 3, 0xf8d9, d8pcsec (0));
650 def_am_insn (fbuge
,, 3, 0xf8da, d8pcsec (0));
651 def_am_insn (fbul
, , 3, 0xf8db, d8pcsec (0));
652 def_am_insn (fbule
,, 3, 0xf8dc, d8pcsec (0));
653 def_am_insn (fbue
, , 3, 0xf8dd, d8pcsec (0));
654 def_am_insn (fleq
, , 2, 0xf0d0, nothing
);
655 def_am_insn (flne
, , 2, 0xf0d1, nothing
);
656 def_am_insn (flgt
, , 2, 0xf0d2, nothing
);
657 def_am_insn (flge
, , 2, 0xf0d3, nothing
);
658 def_am_insn (fllt
, , 2, 0xf0d4, nothing
);
659 def_am_insn (flle
, , 2, 0xf0d5, nothing
);
660 def_am_insn (fluo
, , 2, 0xf0d6, nothing
);
661 def_am_insn (fllg
, , 2, 0xf0d7, nothing
);
662 def_am_insn (flleg
,, 2, 0xf0d8, nothing
);
663 def_am_insn (flug
, , 2, 0xf0d9, nothing
);
664 def_am_insn (fluge
,, 2, 0xf0da, nothing
);
665 def_am_insn (flul
, , 2, 0xf0db, nothing
);
666 def_am_insn (flule
,, 2, 0xf0dc, nothing
);
667 def_am_insn (flue
, , 2, 0xf0dd, nothing
);
669 /* Define the group of conditional jump insns. */
670 func
*condjmp_insns
[] = {
702 /* Define the set of all groups. */
705 { "dcpf", dcpf_insns
},
706 { "bit", bit_insns
},
707 { "fmovs", fmovs_insns
},
708 { "fmovd", fmovd_insns
},
709 { "fmovc", fmovc_insns
},
710 { "sfparith", sfparith_insns
},
711 { "fpacc", fpacc_insns
},
712 { "dfparith", dfparith_insns
},
713 { "fpconv", fpconv_insns
},
714 { "condjmp", condjmp_insns
},
719 main(int argc
, char *argv
[])
721 FILE *as_in
= stdout
, *dis_out
= stderr
;
723 /* Check whether we're filtering insns. */
725 skip_list
= argv
+ 1;
727 /* Output assembler header. */
731 /* Output comments for the testsuite-driver and the initial
732 * disassembler output. */
733 fputs ("#objdump: -dr --prefix-address --show-raw-insn\n"
736 ".*: +file format.*elf32-mn10300.*\n"
738 "Disassembly of section .text:\n",
741 /* Now emit all (selected) insns. */
742 output_groups (groups
, as_in
, dis_out
);
This page took 0.04889 seconds and 4 git commands to generate.