1 /* Copyright (C) 2000, 2003, 2007 Free Software Foundation
2 Contributed by Alexandre Oliva <aoliva@cygnus.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 3 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., 51 Franklin Street - Fifth Floor, Boston,
17 MA 02110-1301, USA. */
19 /* Generator of tests for Maverick.
21 See the following file for usage and documentation. */
22 #include "../all/test-gen.c"
24 /* These are the ARM registers. Some of them have canonical names
25 other than r##, so we'll use both in the asm input, but only the
26 canonical names in the expected disassembler output. */
29 /* Canonical names. */
30 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
31 "r8", "r9", "sl", "fp", "ip", "sp", "lr", "pc",
32 /* Alternate names, i.e., those that can be used in the assembler,
33 * but that will never be emitted by the disassembler. */
34 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
35 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
38 /* The various types of registers: ARM's registers, Maverick's
39 f/d/fx/dx registers, Maverick's accumulators and Maverick's
41 #define armreg(shift) \
42 reg_r (arm_regs, shift, 0xf, mk_get_bits (5u))
43 #define mvreg(prefix, shift) \
44 reg_p ("mv" prefix, shift, mk_get_bits (4u))
45 #define acreg(shift) \
46 reg_p ("mvax", shift, mk_get_bits (2u))
48 literal ("dspsc"), tick_random
50 /* This outputs the condition flag that may follow each ARM insn.
51 Since the condition 15 is invalid, we use it to check that the
52 assembler recognizes the absence of a condition as `al'. However,
53 the disassembler won't ever output `al', so, if we emit it in the
54 assembler, expect the condition to be omitted in the disassembler
58 arm_cond (func_arg
* arg
, insn_data
* data
)
59 #define arm_cond { arm_cond }
61 static const char conds
[16][3] =
63 "eq", "ne", "cs", "cc",
64 "mi", "pl", "vs", "vc",
65 "hi", "ls", "ge", "lt",
68 unsigned val
= get_bits (4u);
70 data
->as_in
= data
->dis_out
= strdup (conds
[val
]);
72 data
->dis_out
= strdup ("");
73 data
->bits
= (val
== 15 ? 14 : val
) << 28;
77 /* The sign of an offset is actually used to determined whether the
78 absolute value of the offset should be added or subtracted, so we
79 must adjust negative values so that they do not overflow: -1024 is
80 not valid, but -0 is distinct from +0. */
82 off8s (func_arg
* arg
, insn_data
* data
)
83 #define off8s { off8s }
88 /* Zero values are problematical.
89 The assembler performs translations on the addressing modes
90 for these values, meaning that we cannot just recreate the
91 disassembler string in the LDST macro without knowing what
92 value had been generated in off8s. */
97 while (val
== -1 || val
== 0);
103 sprintf (value
, ", #-%i", val
);
104 data
->dis_out
= strdup (value
);
105 sprintf (value
, ", #-%i", val
);
106 data
->as_in
= strdup (value
);
107 data
->bits
= val
>> 2;
111 sprintf (value
, ", #%i", val
);
112 data
->as_in
= data
->dis_out
= strdup (value
);
113 data
->bits
= (val
>> 2) | (1 << 23);
119 /* This function generates a 7-bit signed constant, emitted as
120 follows: the 4 least-significant bits are stored in the 4
121 least-significant bits of the word; the 3 most-significant bits are
122 stored in bits 7:5, i.e., bit 4 is skipped. */
124 imm7 (func_arg
*arg
, insn_data
*data
)
125 #define imm7 { imm7 }
127 int val
= get_bits (7s
);
130 data
->bits
= (val
& 0x0f) | (2 * (val
& 0x70));
131 sprintf (value
, "#%i", val
);
132 data
->as_in
= data
->dis_out
= strdup (value
);
136 /* Convenience wrapper to define_insn, that prefixes every insn with
137 `cf' (so, if you specify command-line arguments, remember that `cf'
138 must *not* be part of the string), and post-fixes a condition code.
139 insname and insnvar specify the main insn name and a variant;
140 they're just concatenated, and insnvar is often empty. word is the
141 bit pattern that defines the insn, properly shifted, and funcs is a
142 sequence of funcs that define the operands and the syntax of the
144 #define mv_insn(insname, insnvar, word, funcs...) \
145 define_insn (insname ## insnvar, \
147 insn_bits (insname, word), \
152 /* Define a single LDC/STC variant. op is the main insn opcode; ld
153 stands for load (it should be 0 on stores), dword selects 64-bit
154 operations, pre should be enabled for pre-increment, and wb, for
155 write-back. sep1, sep2 and sep3 are syntactical elements ([]!)
156 that the assembler will use to enable pre and wb. It would
157 probably have been cleaner to couple the syntactical elements with
158 the pre/wb bits directly, but it would have required the definition
159 of more functions. */
160 #define LDST(insname, insnvar, op, ld, dword, regname, pre, wb, sep1, sep2, sep3) \
161 mv_insn (insname, insnvar, \
162 (12 << 24) | (op << 8) | (ld << 20) | (pre << 24) | (dword << 22) | (wb << 21), \
163 mvreg (regname, 12), comma, \
164 lsqbkt, armreg (16), sep1, off8s, sep2, sep3, \
167 /* Define all variants of an LDR or STR instruction, namely,
168 pre-indexed without write-back, pre-indexed with write-back and
170 #define LDSTall(insname, op, ld, dword, regname) \
171 LDST (insname, _p, op, ld, dword, regname, 1, 0, nothing, rsqbkt, nothing); \
172 LDST (insname, _pw, op, ld, dword, regname, 1, 1, nothing, rsqbkt, literal ("!")); \
173 LDST (insname, ,op, ld, dword, regname, 0, 1, rsqbkt, nothing, nothing)
175 /* Produce the insn identifiers of all LDST variants of a given insn.
176 To be used in the initialization of an insn group array. */
177 #define insns_LDSTall(insname) \
178 insn (insname ## _p), insn (insname ## _pw), insn (insname)
180 /* Define a CDP variant that uses two registers, at offsets 12 and 16.
181 The two opcodes and the co-processor number identify the CDP
183 #define CDP2(insname, var, cpnum, opcode1, opcode2, reg1name, reg2name) \
184 mv_insn (insname##var, , \
185 (14 << 24) | ((opcode1) << 20) | ((cpnum) << 8) | ((opcode2) << 5), \
186 mvreg (reg1name, 12), comma, mvreg (reg2name, 16))
188 /* Define a 32-bit integer CDP instruction with two operands. */
189 #define CDP2fx(insname, opcode1, opcode2) \
190 CDP2 (insname, 32, 5, opcode1, opcode2, "fx", "fx")
192 /* Define a 64-bit integer CDP instruction with two operands. */
193 #define CDP2dx(insname, opcode1, opcode2) \
194 CDP2 (insname, 64, 5, opcode1, opcode2, "dx", "dx")
196 /* Define a float CDP instruction with two operands. */
197 #define CDP2f(insname, opcode1, opcode2) \
198 CDP2 (insname, s, 4, opcode1, opcode2, "f", "f")
200 /* Define a double CDP instruction with two operands. */
201 #define CDP2d(insname, opcode1, opcode2) \
202 CDP2 (insname, d, 4, opcode1, opcode2, "d", "d")
204 /* Define a CDP instruction with two register operands and one 7-bit
205 signed immediate generated with imm7. */
206 #define CDP2_imm7(insname, cpnum, opcode1, reg1name, reg2name) \
207 mv_insn (insname, , (14 << 24) | ((opcode1) << 20) | ((cpnum) << 8), \
208 mvreg (reg1name, 12), comma, mvreg (reg2name, 16), comma, imm7, \
211 /* Produce the insn identifiers of CDP floating-point or integer insn
212 pairs (i.e., it appends the suffixes for 32-bit and 64-bit
214 #define CDPfp_insns(insname) \
215 insn (insname ## s), insn (insname ## d)
216 #define CDPx_insns(insname) \
217 insn (insname ## 32), insn (insname ## 64)
219 /* Define a CDP instruction with 3 operands, at offsets 12, 16, 0. */
220 #define CDP3(insname, var, cpnum, opcode1, opcode2, reg1name, reg2name, reg3name) \
221 mv_insn (insname##var, , \
222 (14 << 24) | ((opcode1) << 20) | ((cpnum) << 8) | ((opcode2) << 5), \
223 mvreg (reg1name, 12), comma, mvreg (reg2name, 16), comma, \
224 mvreg (reg3name, 0), tick_random)
226 /* Define a 32-bit integer CDP instruction with three operands. */
227 #define CDP3fx(insname, opcode1, opcode2) \
228 CDP3 (insname, 32, 5, opcode1, opcode2, "fx", "fx", "fx")
230 /* Define a 64-bit integer CDP instruction with three operands. */
231 #define CDP3dx(insname, opcode1, opcode2) \
232 CDP3 (insname, 64, 5, opcode1, opcode2, "dx", "dx", "dx")
234 /* Define a float CDP instruction with three operands. */
235 #define CDP3f(insname, opcode1, opcode2) \
236 CDP3 (insname, s, 4, opcode1, opcode2, "f", "f", "f")
238 /* Define a double CDP instruction with three operands. */
239 #define CDP3d(insname, opcode1, opcode2) \
240 CDP3 (insname, d, 4, opcode1, opcode2, "d", "d", "d")
242 /* Define a CDP instruction with four operands, at offsets 5, 12, 16
243 * and 0. Used only for ACC instructions. */
244 #define CDP4(insname, opcode1, reg2spec, reg3name, reg4name) \
245 mv_insn (insname, , (14 << 24) | ((opcode1) << 20) | (6 << 8), \
246 acreg (5), comma, reg2spec, comma, \
247 mvreg (reg3name, 16), comma, mvreg (reg4name, 0))
249 /* Define a CDP4 instruction with one accumulator operands. */
250 #define CDP41A(insname, opcode1) \
251 CDP4 (insname, opcode1, mvreg ("fx", 12), "fx", "fx")
253 /* Define a CDP4 instruction with two accumulator operands. */
254 #define CDP42A(insname, opcode1) \
255 CDP4 (insname, opcode1, acreg (12), "fx", "fx")
257 /* Define a MCR or MRC instruction with two register operands. */
258 #define MCRC2(insname, cpnum, opcode1, dir, opcode2, reg1spec, reg2spec) \
259 mv_insn (insname, , \
260 ((14 << 24) | ((opcode1) << 21) | ((dir) << 20)| \
261 ((cpnum) << 8) | ((opcode2) << 5) | (1 << 4)), \
262 reg1spec, comma, reg2spec)
264 /* Define a move from a DSP register to an ARM register. */
265 #define MVDSPARM(insname, cpnum, opcode2, regDSPname) \
266 MCRC2 (mv ## insname, cpnum, 0, 0, opcode2, \
267 mvreg (regDSPname, 16), armreg (12))
269 /* Define a move from an ARM register to a DSP register. */
270 #define MVARMDSP(insname, cpnum, opcode2, regDSPname) \
271 MCRC2 (mv ## insname, cpnum, 0, 1, opcode2, \
272 armreg (12), mvreg (regDSPname, 16))
274 /* Move between coprocessor registers. A two operand CDP insn. */
275 #define MCC2(insname, opcode1, opcode2, reg1spec, reg2spec) \
276 mv_insn (insname, , \
277 ((14 << 24) | ((opcode1) << 20) | \
278 (4 << 8) | ((opcode2) << 5)), \
279 reg1spec, comma, reg2spec)
281 /* Define a move from a DSP register to a DSP accumulator. */
282 #define MVDSPACC(insname, opcode2, regDSPname) \
283 MCC2 (mv ## insname, 2, opcode2, acreg (12), mvreg (regDSPname, 16))
285 /* Define a move from a DSP accumulator to a DSP register. */
286 #define MVACCDSP(insname, opcode2, regDSPname) \
287 MCC2 (mv ## insname, 1, opcode2, mvreg (regDSPname, 12), acreg (16))
289 /* Define move insns between a float DSP register and an ARM
291 #define MVf(nameAD, nameDA, opcode2) \
292 MVDSPARM (nameAD, 4, opcode2, "f"); \
293 MVARMDSP (nameDA, 4, opcode2, "f")
295 /* Define move insns between a double DSP register and an ARM
297 #define MVd(nameAD, nameDA, opcode2) \
298 MVDSPARM (nameAD, 4, opcode2, "d"); \
299 MVARMDSP (nameDA, 4, opcode2, "d")
301 /* Define move insns between a 32-bit integer DSP register and an ARM
303 #define MVfx(nameAD, nameDA, opcode2) \
304 MVDSPARM (nameAD, 5, opcode2, "fx"); \
305 MVARMDSP (nameDA, 5, opcode2, "fx")
307 /* Define move insns between a 64-bit integer DSP register and an ARM
309 #define MVdx(nameAD, nameDA, opcode2) \
310 MVDSPARM (nameAD, 5, opcode2, "dx"); \
311 MVARMDSP (nameDA, 5, opcode2, "dx")
313 /* Define move insns between a 32-bit DSP register and a DSP
315 #define MVfxa(nameFA, nameAF, opcode2) \
316 MVDSPACC (nameFA, opcode2, "fx"); \
317 MVACCDSP (nameAF, opcode2, "fx")
319 /* Define move insns between a 64-bit DSP register and a DSP
321 #define MVdxa(nameDA, nameAD, opcode2) \
322 MVDSPACC (nameDA, opcode2, "dx"); \
323 MVACCDSP (nameAD, opcode2, "dx")
325 /* Produce the insn identifiers for a pair of mv insns. */
326 #define insns_MV(name1, name2) \
327 insn (mv ## name1), insn (mv ## name2)
329 /* Define a MCR or MRC instruction with three register operands. */
330 #define MCRC3(insname, cpnum, opcode1, dir, opcode2, reg1spec, reg2spec, reg3spec) \
331 mv_insn (insname, , \
332 ((14 << 24) | ((opcode1) << 21) | ((dir) << 20)| \
333 ((cpnum) << 8) | ((opcode2) << 5) | (1 << 4)), \
334 reg1spec, comma, reg2spec, comma, reg3spec, \
337 /* Define all load_store insns. */
338 LDSTall (ldrs
, 4, 1, 0, "f");
339 LDSTall (ldrd
, 4, 1, 1, "d");
340 LDSTall (ldr32
, 5, 1, 0, "fx");
341 LDSTall (ldr64
, 5, 1, 1, "dx");
342 LDSTall (strs
, 4, 0, 0, "f");
343 LDSTall (strd
, 4, 0, 1, "d");
344 LDSTall (str32
, 5, 0, 0, "fx");
345 LDSTall (str64
, 5, 0, 1, "dx");
347 /* Create the load_store insn group. */
348 func
*load_store_insns
[] =
350 insns_LDSTall (ldrs
), insns_LDSTall (ldrd
),
351 insns_LDSTall (ldr32
), insns_LDSTall (ldr64
),
352 insns_LDSTall (strs
), insns_LDSTall (strd
),
353 insns_LDSTall (str32
), insns_LDSTall (str64
),
357 /* Define all move insns. */
361 MVdx (64lr
, r64l
, 0);
362 MVdx (64hr
, r64h
, 1);
363 MVfxa (al32
, 32al
, 2);
364 MVfxa (am32
, 32am
, 3);
365 MVfxa (ah32
, 32ah
, 4);
368 MCC2 (mvsc32
, 2, 7, dspsc
, mvreg ("dx", 12));
369 MCC2 (mv32sc
, 1, 7, mvreg ("dx", 12), dspsc
);
370 CDP2 (cpys
, , 4, 0, 0, "f", "f");
371 CDP2 (cpyd
, , 4, 0, 1, "d", "d");
373 /* Create the move insns group. */
374 func
* move_insns
[] =
376 insns_MV (sr
, rs
), insns_MV (dlr
, rdl
), insns_MV (dhr
, rdh
),
377 insns_MV (64lr
, r64l
), insns_MV (64hr
, r64h
),
378 insns_MV (al32
, 32al
), insns_MV (am32
, 32am
), insns_MV (ah32
, 32ah
),
379 insns_MV (a32
, 32a
), insns_MV (a64
, 64a
),
380 insn (mvsc32
), insn (mv32sc
), insn (cpys
), insn (cpyd
),
384 /* Define all conversion insns. */
385 CDP2 (cvtsd
, , 4, 0, 3, "d", "f");
386 CDP2 (cvtds
, , 4, 0, 2, "f", "d");
387 CDP2 (cvt32s
, , 4, 0, 4, "f", "fx");
388 CDP2 (cvt32d
, , 4, 0, 5, "d", "fx");
389 CDP2 (cvt64s
, , 4, 0, 6, "f", "dx");
390 CDP2 (cvt64d
, , 4, 0, 7, "d", "dx");
391 CDP2 (cvts32
, , 5, 1, 4, "fx", "f");
392 CDP2 (cvtd32
, , 5, 1, 5, "fx", "d");
393 CDP2 (truncs32
, , 5, 1, 6, "fx", "f");
394 CDP2 (truncd32
, , 5, 1, 7, "fx", "d");
396 /* Create the conv insns group. */
397 func
* conv_insns
[] =
399 insn (cvtsd
), insn (cvtds
), insn (cvt32s
), insn (cvt32d
),
400 insn (cvt64s
), insn (cvt64d
), insn (cvts32
), insn (cvtd32
),
401 insn (truncs32
), insn (truncd32
),
405 /* Define all shift insns. */
406 MCRC3 (rshl32
, 5, 0, 0, 2, mvreg ("fx", 16), mvreg ("fx", 0), armreg (12));
407 MCRC3 (rshl64
, 5, 0, 0, 3, mvreg ("dx", 16), mvreg ("dx", 0), armreg (12));
408 CDP2_imm7 (sh32
, 5, 0, "fx", "fx");
409 CDP2_imm7 (sh64
, 5, 2, "dx", "dx");
411 /* Create the shift insns group. */
412 func
*shift_insns
[] =
414 insn (rshl32
), insn (rshl64
),
415 insn (sh32
), insn (sh64
),
419 /* Define all comparison insns. */
420 MCRC3 (cmps
, 4, 0, 1, 4, armreg (12), mvreg ("f", 16), mvreg ("f", 0));
421 MCRC3 (cmpd
, 4, 0, 1, 5, armreg (12), mvreg ("d", 16), mvreg ("d", 0));
422 MCRC3 (cmp32
, 5, 0, 1, 4, armreg (12), mvreg ("fx", 16), mvreg ("fx", 0));
423 MCRC3 (cmp64
, 5, 0, 1, 5, armreg (12), mvreg ("dx", 16), mvreg ("dx", 0));
425 /* Create the comp insns group. */
428 insn (cmps
), insn (cmpd
),
429 insn (cmp32
), insn (cmp64
),
433 /* Define all floating-point arithmetic insns. */
445 /* Create the fp-arith insns group. */
446 func
*fp_arith_insns
[] =
448 CDPfp_insns (abs
), CDPfp_insns (neg
),
449 CDPfp_insns (add
), CDPfp_insns (sub
), CDPfp_insns (mul
),
453 /* Define all integer arithmetic insns. */
467 /* Create the int-arith insns group. */
468 func
* int_arith_insns
[] =
470 CDPx_insns (abs
), CDPx_insns (neg
),
471 CDPx_insns (add
), CDPx_insns (sub
), CDPx_insns (mul
),
472 insn (mac32
), insn (msc32
),
476 /* Define all accumulator arithmetic insns. */
482 /* Create the acc-arith insns group. */
483 func
* acc_arith_insns
[] =
485 insn (madd32
), insn (msub32
),
486 insn (madda32
), insn (msuba32
),
490 /* Create the set of all groups. */
493 { "load_store", load_store_insns
},
494 { "move", move_insns
},
495 { "conv", conv_insns
},
496 { "shift", shift_insns
},
497 { "comp", comp_insns
},
498 { "fp_arith", fp_arith_insns
},
499 { "int_arith", int_arith_insns
},
500 { "acc_arith", acc_arith_insns
},
505 main (int argc
, char *argv
[])
507 FILE *as_in
= stdout
, *dis_out
= stderr
;
509 /* Check whether we're filtering insns. */
511 skip_list
= argv
+ 1;
513 /* Output assembler header. */
517 /* Output comments for the testsuite-driver and the initial
518 disassembler output. */
519 fputs ("#objdump: -dr --prefix-address --show-raw-insn\n"
521 "#as: -mcpu=ep9312\n"
523 "# Test the instructions of the Cirrus Maverick floating point co-processor\n"
525 ".*: +file format.*arm.*\n"
527 "Disassembly of section .text:\n",
530 /* Now emit all (selected) insns. */
531 output_groups (groups
, as_in
, dis_out
);
This page took 0.041249 seconds and 4 git commands to generate.