?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[gdb/exp] Fix printing of out of bounds struct members
[binutils-gdb.git] / opcodes / kvx-dis.c
blobf4d709bb8f8577889dd3ea7a88003a92d805e875
1 /* kvx-dis.c -- Kalray MPPA generic disassembler.
2 Copyright (C) 2009-2024 Free Software Foundation, Inc.
3 Contributed by Kalray SA.
4
5 This file is part of the GNU opcodes library.
6
7 This library is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 It is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; see the file COPYING3. If not,
19 see <http://www.gnu.org/licenses/>. */
20
21 #define STATIC_TABLE
22 #define DEFINE_TABLE
23
24 #include "sysdep.h"
25 #include "disassemble.h"
26 #include "libiberty.h"
27 #include "opintl.h"
28 #include <assert.h>
29 #include "elf-bfd.h"
30 #include "kvx-dis.h"
31
32 #include "elf/kvx.h"
33 #include "opcode/kvx.h"
34
35 /* Steering values for the kvx VLIW architecture. */
36
37 typedef enum
38 {
39 Steering_BCU,
40 Steering_LSU,
41 Steering_MAU,
42 Steering_ALU,
43 Steering__
44 } enum_Steering;
45 typedef uint8_t Steering;
46
47 /* BundleIssue enumeration. */
48
49 typedef enum
50 {
51 BundleIssue_BCU,
52 BundleIssue_TCA,
53 BundleIssue_ALU0,
54 BundleIssue_ALU1,
55 BundleIssue_MAU,
56 BundleIssue_LSU,
57 BundleIssue__,
58 } enum_BundleIssue;
59 typedef uint8_t BundleIssue;
60
61 /* An IMMX syllable is associated with the BundleIssue Extension_BundleIssue[extension]. */
62 static const BundleIssue Extension_BundleIssue[] = {
63 BundleIssue_ALU0,
64 BundleIssue_ALU1,
65 BundleIssue_MAU,
66 BundleIssue_LSU
67 };
68
69 static inline int
70 kvx_steering (uint32_t x)
71 {
72 return (((x) & 0x60000000) >> 29);
73 }
74
75 static inline int
76 kvx_extension (uint32_t x)
77 {
78 return (((x) & 0x18000000) >> 27);
79 }
80
81 static inline int
82 kvx_has_parallel_bit (uint32_t x)
83 {
84 return (((x) & 0x80000000) == 0x80000000);
85 }
86
87 static inline int
88 kvx_is_tca_opcode (uint32_t x)
89 {
90 unsigned major = ((x) >> 24) & 0x1F;
91 return (major > 1) && (major < 8);
92 }
93
94 static inline int
95 kvx_is_nop_opcode (uint32_t x)
96 {
97 return ((x) << 1) == 0xFFFFFFFE;
98 }
99
100 /* A raw instruction. */
101
102 struct insn_s
103 {
104 uint32_t syllables[KVXMAXSYLLABLES];
105 int len;
106 };
107 typedef struct insn_s insn_t;
108
109
110 static uint32_t bundle_words[KVXMAXBUNDLEWORDS];
111
112 static insn_t bundle_insn[KVXMAXBUNDLEISSUE];
113
114 /* A re-interpreted instruction. */
115
116 struct instr_s
117 {
118 int valid;
119 int opcode;
120 int immx[2];
121 int immx_valid[2];
122 int immx_count;
123 int nb_syllables;
124 };
125
126 /* Option for "pretty printing", ie, not the usual little endian objdump output. */
127 static int opt_pretty = 0;
128 /* Option for not emiting a new line between all bundles. */
129 static int opt_compact_assembly = 0;
130
131 void
132 parse_kvx_dis_option (const char *option)
133 {
134 /* Try to match options that are simple flags. */
135 if (startswith (option, "pretty"))
136 {
137 opt_pretty = 1;
138 return;
139 }
140
141 if (startswith (option, "compact-assembly"))
142 {
143 opt_compact_assembly = 1;
144 return;
145 }
146
147 if (startswith (option, "no-compact-assembly"))
148 {
149 opt_compact_assembly = 0;
150 return;
151 }
152
153 /* Invalid option. */
154 opcodes_error_handler (_("unrecognised disassembler option: %s"), option);
155 }
156
157 static void
158 parse_kvx_dis_options (const char *options)
159 {
160 const char *option_end;
161
162 if (options == NULL)
163 return;
164
165 while (*options != '\0')
166 {
167 /* Skip empty options. */
168 if (*options == ',')
169 {
170 options++;
171 continue;
172 }
173
174 /* We know that *options is neither NUL or a comma. */
175 option_end = options + 1;
176 while (*option_end != ',' && *option_end != '\0')
177 option_end++;
178
179 parse_kvx_dis_option (options);
180
181 /* Go on to the next one. If option_end points to a comma, it
182 will be skipped above. */
183 options = option_end;
184 }
185 }
186
187 struct kvx_dis_env
188 {
189 int kvx_arch_size;
190 struct kvxopc *opc_table;
191 struct kvx_Register *kvx_registers;
192 const char ***kvx_modifiers;
193 int *kvx_dec_registers;
194 int *kvx_regfiles;
195 unsigned int kvx_max_dec_registers;
196 int initialized_p;
197 };
198
199 static struct kvx_dis_env env = {
200 .kvx_arch_size = 0,
201 .opc_table = NULL,
202 .kvx_registers = NULL,
203 .kvx_modifiers = NULL,
204 .kvx_dec_registers = NULL,
205 .kvx_regfiles = NULL,
206 .initialized_p = 0,
207 .kvx_max_dec_registers = 0
208 };
209
210 static void
211 kvx_dis_init (struct disassemble_info *info)
212 {
213 env.kvx_arch_size = 32;
214 switch (info->mach)
215 {
216 case bfd_mach_kv3_1_64:
217 env.kvx_arch_size = 64;
218 /* fallthrough */
219 case bfd_mach_kv3_1_usr:
220 case bfd_mach_kv3_1:
221 default:
222 env.opc_table = kvx_kv3_v1_optab;
223 env.kvx_regfiles = kvx_kv3_v1_regfiles;
224 env.kvx_registers = kvx_kv3_v1_registers;
225 env.kvx_modifiers = kvx_kv3_v1_modifiers;
226 env.kvx_dec_registers = kvx_kv3_v1_dec_registers;
227 break;
228 case bfd_mach_kv3_2_64:
229 env.kvx_arch_size = 64;
230 /* fallthrough */
231 case bfd_mach_kv3_2_usr:
232 case bfd_mach_kv3_2:
233 env.opc_table = kvx_kv3_v2_optab;
234 env.kvx_regfiles = kvx_kv3_v2_regfiles;
235 env.kvx_registers = kvx_kv3_v2_registers;
236 env.kvx_modifiers = kvx_kv3_v2_modifiers;
237 env.kvx_dec_registers = kvx_kv3_v2_dec_registers;
238 break;
239 case bfd_mach_kv4_1_64:
240 env.kvx_arch_size = 64;
241 /* fallthrough */
242 case bfd_mach_kv4_1_usr:
243 case bfd_mach_kv4_1:
244 env.opc_table = kvx_kv4_v1_optab;
245 env.kvx_regfiles = kvx_kv4_v1_regfiles;
246 env.kvx_registers = kvx_kv4_v1_registers;
247 env.kvx_modifiers = kvx_kv4_v1_modifiers;
248 env.kvx_dec_registers = kvx_kv4_v1_dec_registers;
249 break;
250 }
251
252 env.kvx_max_dec_registers = env.kvx_regfiles[KVX_REGFILE_DEC_REGISTERS];
253
254 if (info->disassembler_options)
255 parse_kvx_dis_options (info->disassembler_options);
256
257 env.initialized_p = 1;
258 }
259
260 static bool
261 kvx_reassemble_bundle (int wordcount, int *_insncount)
262 {
263
264 /* Debugging flag. */
265 int debug = 0;
266
267 /* Available resources. */
268 int bcu_taken = 0;
269 int tca_taken = 0;
270 int alu0_taken = 0;
271 int alu1_taken = 0;
272 int mau_taken = 0;
273 int lsu_taken = 0;
274
275 if (debug)
276 fprintf (stderr, "kvx_reassemble_bundle: wordcount = %d\n", wordcount);
277
278 if (wordcount > KVXMAXBUNDLEWORDS)
279 {
280 if (debug)
281 fprintf (stderr, "bundle exceeds maximum size\n");
282 return false;
283 }
284
285 struct instr_s instr[KVXMAXBUNDLEISSUE];
286 memset (instr, 0, sizeof (instr));
287 assert (KVXMAXBUNDLEISSUE >= BundleIssue__);
288
289 int i;
290 unsigned int j;
291
292 for (i = 0; i < wordcount; i++)
293 {
294 uint32_t syllable = bundle_words[i];
295 switch (kvx_steering (syllable))
296 {
297 case Steering_BCU:
298 /* BCU or TCA instruction. */
299 if (i == 0)
300 {
301 if (kvx_is_tca_opcode (syllable))
302 {
303 if (tca_taken)
304 {
305 if (debug)
306 fprintf (stderr, "Too many TCA instructions");
307 return false;
308 }
309 if (debug)
310 fprintf (stderr,
311 "Syllable 0: Set valid on TCA for instr %d with 0x%x\n",
312 BundleIssue_TCA, syllable);
313 instr[BundleIssue_TCA].valid = 1;
314 instr[BundleIssue_TCA].opcode = syllable;
315 instr[BundleIssue_TCA].nb_syllables = 1;
316 tca_taken = 1;
317 }
318 else
319 {
320 if (debug)
321 fprintf (stderr,
322 "Syllable 0: Set valid on BCU for instr %d with 0x%x\n",
323 BundleIssue_BCU, syllable);
324
325 instr[BundleIssue_BCU].valid = 1;
326 instr[BundleIssue_BCU].opcode = syllable;
327 instr[BundleIssue_BCU].nb_syllables = 1;
328 bcu_taken = 1;
329 }
330 }
331 else
332 {
333 if (i == 1 && bcu_taken && kvx_is_tca_opcode (syllable))
334 {
335 if (tca_taken)
336 {
337 if (debug)
338 fprintf (stderr, "Too many TCA instructions");
339 return false;
340 }
341 if (debug)
342 fprintf (stderr,
343 "Syllable 0: Set valid on TCA for instr %d with 0x%x\n",
344 BundleIssue_TCA, syllable);
345 instr[BundleIssue_TCA].valid = 1;
346 instr[BundleIssue_TCA].opcode = syllable;
347 instr[BundleIssue_TCA].nb_syllables = 1;
348 tca_taken = 1;
349 }
350 else
351 {
352 /* Not first syllable in bundle, IMMX. */
353 struct instr_s *instr_p =
354 &(instr[Extension_BundleIssue[kvx_extension (syllable)]]);
355 int immx_count = instr_p->immx_count;
356 if (immx_count > 1)
357 {
358 if (debug)
359 fprintf (stderr, "Too many IMMX syllables");
360 return false;
361 }
362 instr_p->immx[immx_count] = syllable;
363 instr_p->immx_valid[immx_count] = 1;
364 instr_p->nb_syllables++;
365 if (debug)
366 fprintf (stderr,
367 "Set IMMX[%d] on instr %d for extension %d @ %d\n",
368 immx_count,
369 Extension_BundleIssue[kvx_extension (syllable)],
370 kvx_extension (syllable), i);
371 instr_p->immx_count = immx_count + 1;
372 }
373 }
374 break;
375
376 case Steering_ALU:
377 if (alu0_taken == 0)
378 {
379 if (debug)
380 fprintf (stderr, "Set valid on ALU0 for instr %d with 0x%x\n",
381 BundleIssue_ALU0, syllable);
382 instr[BundleIssue_ALU0].valid = 1;
383 instr[BundleIssue_ALU0].opcode = syllable;
384 instr[BundleIssue_ALU0].nb_syllables = 1;
385 alu0_taken = 1;
386 }
387 else if (alu1_taken == 0)
388 {
389 if (debug)
390 fprintf (stderr, "Set valid on ALU1 for instr %d with 0x%x\n",
391 BundleIssue_ALU1, syllable);
392 instr[BundleIssue_ALU1].valid = 1;
393 instr[BundleIssue_ALU1].opcode = syllable;
394 instr[BundleIssue_ALU1].nb_syllables = 1;
395 alu1_taken = 1;
396 }
397 else if (mau_taken == 0)
398 {
399 if (debug)
400 fprintf (stderr,
401 "Set valid on MAU (ALU) for instr %d with 0x%x\n",
402 BundleIssue_MAU, syllable);
403 instr[BundleIssue_MAU].valid = 1;
404 instr[BundleIssue_MAU].opcode = syllable;
405 instr[BundleIssue_MAU].nb_syllables = 1;
406 mau_taken = 1;
407 }
408 else if (lsu_taken == 0)
409 {
410 if (debug)
411 fprintf (stderr,
412 "Set valid on LSU (ALU) for instr %d with 0x%x\n",
413 BundleIssue_LSU, syllable);
414 instr[BundleIssue_LSU].valid = 1;
415 instr[BundleIssue_LSU].opcode = syllable;
416 instr[BundleIssue_LSU].nb_syllables = 1;
417 lsu_taken = 1;
418 }
419 else if (kvx_is_nop_opcode (syllable))
420 {
421 if (debug)
422 fprintf (stderr, "Ignoring NOP (ALU) syllable\n");
423 }
424 else
425 {
426 if (debug)
427 fprintf (stderr, "Too many ALU instructions");
428 return false;
429 }
430 break;
431
432 case Steering_MAU:
433 if (mau_taken == 1)
434 {
435 if (debug)
436 fprintf (stderr, "Too many MAU instructions");
437 return false;
438 }
439 else
440 {
441 if (debug)
442 fprintf (stderr, "Set valid on MAU for instr %d with 0x%x\n",
443 BundleIssue_MAU, syllable);
444 instr[BundleIssue_MAU].valid = 1;
445 instr[BundleIssue_MAU].opcode = syllable;
446 instr[BundleIssue_MAU].nb_syllables = 1;
447 mau_taken = 1;
448 }
449 break;
450
451 case Steering_LSU:
452 if (lsu_taken == 1)
453 {
454 if (debug)
455 fprintf (stderr, "Too many LSU instructions");
456 return false;
457 }
458 else
459 {
460 if (debug)
461 fprintf (stderr, "Set valid on LSU for instr %d with 0x%x\n",
462 BundleIssue_LSU, syllable);
463 instr[BundleIssue_LSU].valid = 1;
464 instr[BundleIssue_LSU].opcode = syllable;
465 instr[BundleIssue_LSU].nb_syllables = 1;
466 lsu_taken = 1;
467 }
468 }
469 if (debug)
470 fprintf (stderr, "Continue %d < %d?\n", i, wordcount);
471 }
472
473 /* Fill bundle_insn and count read syllables. */
474 int instr_idx = 0;
475 for (i = 0; i < KVXMAXBUNDLEISSUE; i++)
476 {
477 if (instr[i].valid == 1)
478 {
479 int syllable_idx = 0;
480
481 /* First copy opcode. */
482 bundle_insn[instr_idx].syllables[syllable_idx++] = instr[i].opcode;
483 bundle_insn[instr_idx].len = 1;
484
485 for (j = 0; j < 2; j++)
486 {
487 if (instr[i].immx_valid[j])
488 {
489 if (debug)
490 fprintf (stderr, "Instr %d valid immx[%d] is valid\n", i,
491 j);
492 bundle_insn[instr_idx].syllables[syllable_idx++] =
493 instr[i].immx[j];
494 bundle_insn[instr_idx].len++;
495 }
496 }
497
498 if (debug)
499 fprintf (stderr,
500 "Instr %d valid, copying in bundle_insn (%d syllables <-> %d)\n",
501 i, bundle_insn[instr_idx].len, instr[i].nb_syllables);
502 instr_idx++;
503 }
504 }
505
506 if (debug)
507 fprintf (stderr, "End => %d instructions\n", instr_idx);
508
509 *_insncount = instr_idx;
510 return true;
511 }
512
513 struct decoded_insn
514 {
515 /* The entry in the opc_table. */
516 struct kvxopc *opc;
517 /* The number of operands. */
518 int nb_ops;
519 /* The content of an operands. */
520 struct
521 {
522 enum
523 {
524 CAT_REGISTER,
525 CAT_MODIFIER,
526 CAT_IMMEDIATE,
527 } type;
528 /* The value of the operands. */
529 uint64_t val;
530 /* If it is an immediate, its sign. */
531 int sign;
532 /* If it is an immediate, is it pc relative. */
533 int pcrel;
534 /* The width of the operand. */
535 int width;
536 /* If it is a modifier, the modifier category.
537 An index in the modifier table. */
538 int mod_idx;
539 } operands[KVXMAXOPERANDS];
540 };
541
542 static int
543 decode_insn (bfd_vma memaddr, insn_t * insn, struct decoded_insn *res)
544 {
545
546 int found = 0;
547 int idx = 0;
548 for (struct kvxopc * op = env.opc_table;
549 op->as_op && (((char) op->as_op[0]) != 0); op++)
550 {
551 /* Find the format of this insn. */
552 int opcode_match = 1;
553
554 if (op->wordcount != insn->len)
555 continue;
556
557 for (int i = 0; i < op->wordcount; i++)
558 if ((op->codewords[i].mask & insn->syllables[i]) !=
559 op->codewords[i].opcode)
560 opcode_match = 0;
561
562 int encoding_space_flags = env.kvx_arch_size == 32
563 ? kvxOPCODE_FLAG_MODE32 : kvxOPCODE_FLAG_MODE64;
564
565 for (int i = 0; i < op->wordcount; i++)
566 if (!(op->codewords[i].flags & encoding_space_flags))
567 opcode_match = 0;
568
569 if (opcode_match)
570 {
571 res->opc = op;
572
573 for (int i = 0; op->format[i]; i++)
574 {
575 struct kvx_bitfield *bf = op->format[i]->bfield;
576 int bf_nb = op->format[i]->bitfields;
577 int width = op->format[i]->width;
578 int type = op->format[i]->type;
579 const char *type_name = op->format[i]->tname;
580 int flags = op->format[i]->flags;
581 int shift = op->format[i]->shift;
582 int bias = op->format[i]->bias;
583 uint64_t value = 0;
584
585 for (int bf_idx = 0; bf_idx < bf_nb; bf_idx++)
586 {
587 int insn_idx = (int) bf[bf_idx].to_offset / 32;
588 int to_offset = bf[bf_idx].to_offset % 32;
589 uint64_t encoded_value =
590 insn->syllables[insn_idx] >> to_offset;
591 encoded_value &= (1LL << bf[bf_idx].size) - 1;
592 value |= encoded_value << bf[bf_idx].from_offset;
593 }
594 if (flags & kvxSIGNED)
595 {
596 uint64_t signbit = 1LL << (width - 1);
597 value = (value ^ signbit) - signbit;
598 }
599 value = (value << shift) + bias;
600
601 #define KVX_PRINT_REG(regfile,value) \
602 if(env.kvx_regfiles[regfile]+value < env.kvx_max_dec_registers) { \
603 res->operands[idx].val = env.kvx_dec_registers[env.kvx_regfiles[regfile]+value]; \
604 res->operands[idx].type = CAT_REGISTER; \
605 idx++; \
606 } else { \
607 res->operands[idx].val = ~0; \
608 res->operands[idx].type = CAT_REGISTER; \
609 idx++; \
610 }
611
612 if (env.opc_table == kvx_kv3_v1_optab)
613 {
614 switch (type)
615 {
616 case RegClass_kv3_v1_singleReg:
617 KVX_PRINT_REG (KVX_REGFILE_DEC_GPR, value)
618 break;
619 case RegClass_kv3_v1_pairedReg:
620 KVX_PRINT_REG (KVX_REGFILE_DEC_PGR, value)
621 break;
622 case RegClass_kv3_v1_quadReg:
623 KVX_PRINT_REG (KVX_REGFILE_DEC_QGR, value)
624 break;
625 case RegClass_kv3_v1_systemReg:
626 case RegClass_kv3_v1_aloneReg:
627 case RegClass_kv3_v1_onlyraReg:
628 case RegClass_kv3_v1_onlygetReg:
629 case RegClass_kv3_v1_onlysetReg:
630 case RegClass_kv3_v1_onlyfxReg:
631 KVX_PRINT_REG (KVX_REGFILE_DEC_SFR, value)
632 break;
633 case RegClass_kv3_v1_coproReg0M4:
634 case RegClass_kv3_v1_coproReg1M4:
635 case RegClass_kv3_v1_coproReg2M4:
636 case RegClass_kv3_v1_coproReg3M4:
637 KVX_PRINT_REG (KVX_REGFILE_DEC_XCR, value)
638 break;
639 case RegClass_kv3_v1_blockRegE:
640 case RegClass_kv3_v1_blockRegO:
641 case RegClass_kv3_v1_blockReg0M4:
642 case RegClass_kv3_v1_blockReg1M4:
643 case RegClass_kv3_v1_blockReg2M4:
644 case RegClass_kv3_v1_blockReg3M4:
645 KVX_PRINT_REG (KVX_REGFILE_DEC_XBR, value)
646 break;
647 case RegClass_kv3_v1_vectorReg:
648 case RegClass_kv3_v1_vectorRegE:
649 case RegClass_kv3_v1_vectorRegO:
650 KVX_PRINT_REG (KVX_REGFILE_DEC_XVR, value)
651 break;
652 case RegClass_kv3_v1_tileReg:
653 KVX_PRINT_REG (KVX_REGFILE_DEC_XTR, value)
654 break;
655 case RegClass_kv3_v1_matrixReg:
656 KVX_PRINT_REG (KVX_REGFILE_DEC_XMR, value)
657 break;
658 case Immediate_kv3_v1_sysnumber:
659 case Immediate_kv3_v1_signed10:
660 case Immediate_kv3_v1_signed16:
661 case Immediate_kv3_v1_signed27:
662 case Immediate_kv3_v1_wrapped32:
663 case Immediate_kv3_v1_signed37:
664 case Immediate_kv3_v1_signed43:
665 case Immediate_kv3_v1_signed54:
666 case Immediate_kv3_v1_wrapped64:
667 case Immediate_kv3_v1_unsigned6:
668 res->operands[idx].val = value;
669 res->operands[idx].sign = flags & kvxSIGNED;
670 res->operands[idx].width = width;
671 res->operands[idx].type = CAT_IMMEDIATE;
672 res->operands[idx].pcrel = 0;
673 idx++;
674 break;
675 case Immediate_kv3_v1_pcrel17:
676 case Immediate_kv3_v1_pcrel27:
677 res->operands[idx].val = value + memaddr;
678 res->operands[idx].sign = flags & kvxSIGNED;
679 res->operands[idx].width = width;
680 res->operands[idx].type = CAT_IMMEDIATE;
681 res->operands[idx].pcrel = 1;
682 idx++;
683 break;
684 case Modifier_kv3_v1_column:
685 case Modifier_kv3_v1_comparison:
686 case Modifier_kv3_v1_doscale:
687 case Modifier_kv3_v1_exunum:
688 case Modifier_kv3_v1_floatcomp:
689 case Modifier_kv3_v1_qindex:
690 case Modifier_kv3_v1_rectify:
691 case Modifier_kv3_v1_rounding:
692 case Modifier_kv3_v1_roundint:
693 case Modifier_kv3_v1_saturate:
694 case Modifier_kv3_v1_scalarcond:
695 case Modifier_kv3_v1_silent:
696 case Modifier_kv3_v1_simplecond:
697 case Modifier_kv3_v1_speculate:
698 case Modifier_kv3_v1_splat32:
699 case Modifier_kv3_v1_variant:
700 {
701 int sz = 0;
702 int mod_idx = type - Modifier_kv3_v1_column;
703 for (sz = 0; env.kvx_modifiers[mod_idx][sz]; ++sz);
704 const char *mod = value < (unsigned) sz
705 ? env.kvx_modifiers[mod_idx][value] : NULL;
706 if (!mod) goto retry;
707 res->operands[idx].val = value;
708 res->operands[idx].type = CAT_MODIFIER;
709 res->operands[idx].mod_idx = mod_idx;
710 idx++;
711 }
712 break;
713 default:
714 fprintf (stderr, "error: unexpected operand type (%s)\n",
715 type_name);
716 exit (-1);
717 };
718 }
719 else if (env.opc_table == kvx_kv3_v2_optab)
720 {
721 switch (type)
722 {
723 case RegClass_kv3_v2_singleReg:
724 KVX_PRINT_REG (KVX_REGFILE_DEC_GPR, value)
725 break;
726 case RegClass_kv3_v2_pairedReg:
727 KVX_PRINT_REG (KVX_REGFILE_DEC_PGR, value)
728 break;
729 case RegClass_kv3_v2_quadReg:
730 KVX_PRINT_REG (KVX_REGFILE_DEC_QGR, value)
731 break;
732 case RegClass_kv3_v2_systemReg:
733 case RegClass_kv3_v2_aloneReg:
734 case RegClass_kv3_v2_onlyraReg:
735 case RegClass_kv3_v2_onlygetReg:
736 case RegClass_kv3_v2_onlysetReg:
737 case RegClass_kv3_v2_onlyfxReg:
738 KVX_PRINT_REG (KVX_REGFILE_DEC_SFR, value)
739 break;
740 case RegClass_kv3_v2_coproReg:
741 case RegClass_kv3_v2_coproReg0M4:
742 case RegClass_kv3_v2_coproReg1M4:
743 case RegClass_kv3_v2_coproReg2M4:
744 case RegClass_kv3_v2_coproReg3M4:
745 KVX_PRINT_REG (KVX_REGFILE_DEC_XCR, value)
746 break;
747 case RegClass_kv3_v2_blockReg:
748 case RegClass_kv3_v2_blockRegE:
749 case RegClass_kv3_v2_blockRegO:
750 KVX_PRINT_REG (KVX_REGFILE_DEC_XBR, value)
751 break;
752 case RegClass_kv3_v2_vectorReg:
753 KVX_PRINT_REG (KVX_REGFILE_DEC_XVR, value)
754 break;
755 case RegClass_kv3_v2_tileReg:
756 KVX_PRINT_REG (KVX_REGFILE_DEC_XTR, value)
757 break;
758 case RegClass_kv3_v2_matrixReg:
759 KVX_PRINT_REG (KVX_REGFILE_DEC_XMR, value)
760 break;
761 case RegClass_kv3_v2_buffer2Reg:
762 KVX_PRINT_REG (KVX_REGFILE_DEC_X2R, value)
763 break;
764 case RegClass_kv3_v2_buffer4Reg:
765 KVX_PRINT_REG (KVX_REGFILE_DEC_X4R, value)
766 break;
767 case RegClass_kv3_v2_buffer8Reg:
768 KVX_PRINT_REG (KVX_REGFILE_DEC_X8R, value)
769 break;
770 case RegClass_kv3_v2_buffer16Reg:
771 KVX_PRINT_REG (KVX_REGFILE_DEC_X16R, value)
772 break;
773 case RegClass_kv3_v2_buffer32Reg:
774 KVX_PRINT_REG (KVX_REGFILE_DEC_X32R, value)
775 break;
776 case RegClass_kv3_v2_buffer64Reg:
777 KVX_PRINT_REG (KVX_REGFILE_DEC_X64R, value)
778 break;
779 case Immediate_kv3_v2_brknumber:
780 case Immediate_kv3_v2_sysnumber:
781 case Immediate_kv3_v2_signed10:
782 case Immediate_kv3_v2_signed16:
783 case Immediate_kv3_v2_signed27:
784 case Immediate_kv3_v2_wrapped32:
785 case Immediate_kv3_v2_signed37:
786 case Immediate_kv3_v2_signed43:
787 case Immediate_kv3_v2_signed54:
788 case Immediate_kv3_v2_wrapped64:
789 case Immediate_kv3_v2_unsigned6:
790 res->operands[idx].val = value;
791 res->operands[idx].sign = flags & kvxSIGNED;
792 res->operands[idx].width = width;
793 res->operands[idx].type = CAT_IMMEDIATE;
794 res->operands[idx].pcrel = 0;
795 idx++;
796 break;
797 case Immediate_kv3_v2_pcrel27:
798 case Immediate_kv3_v2_pcrel17:
799 res->operands[idx].val = value + memaddr;
800 res->operands[idx].sign = flags & kvxSIGNED;
801 res->operands[idx].width = width;
802 res->operands[idx].type = CAT_IMMEDIATE;
803 res->operands[idx].pcrel = 1;
804 idx++;
805 break;
806 case Modifier_kv3_v2_accesses:
807 case Modifier_kv3_v2_boolcas:
808 case Modifier_kv3_v2_cachelev:
809 case Modifier_kv3_v2_channel:
810 case Modifier_kv3_v2_coherency:
811 case Modifier_kv3_v2_comparison:
812 case Modifier_kv3_v2_conjugate:
813 case Modifier_kv3_v2_doscale:
814 case Modifier_kv3_v2_exunum:
815 case Modifier_kv3_v2_floatcomp:
816 case Modifier_kv3_v2_hindex:
817 case Modifier_kv3_v2_lsomask:
818 case Modifier_kv3_v2_lsumask:
819 case Modifier_kv3_v2_lsupack:
820 case Modifier_kv3_v2_qindex:
821 case Modifier_kv3_v2_rounding:
822 case Modifier_kv3_v2_scalarcond:
823 case Modifier_kv3_v2_shuffleV:
824 case Modifier_kv3_v2_shuffleX:
825 case Modifier_kv3_v2_silent:
826 case Modifier_kv3_v2_simplecond:
827 case Modifier_kv3_v2_speculate:
828 case Modifier_kv3_v2_splat32:
829 case Modifier_kv3_v2_transpose:
830 case Modifier_kv3_v2_variant:
831 {
832 int sz = 0;
833 int mod_idx = type - Modifier_kv3_v2_accesses;
834 for (sz = 0; env.kvx_modifiers[mod_idx][sz];
835 ++sz);
836 const char *mod = value < (unsigned) sz
837 ? env.kvx_modifiers[mod_idx][value] : NULL;
838 if (!mod) goto retry;
839 res->operands[idx].val = value;
840 res->operands[idx].type = CAT_MODIFIER;
841 res->operands[idx].mod_idx = mod_idx;
842 idx++;
843 };
844 break;
845 default:
846 fprintf (stderr,
847 "error: unexpected operand type (%s)\n",
848 type_name);
849 exit (-1);
850 };
851 }
852 else if (env.opc_table == kvx_kv4_v1_optab)
853 {
854 switch (type)
855 {
856
857 case RegClass_kv4_v1_singleReg:
858 KVX_PRINT_REG (KVX_REGFILE_DEC_GPR, value)
859 break;
860 case RegClass_kv4_v1_pairedReg:
861 KVX_PRINT_REG (KVX_REGFILE_DEC_PGR, value)
862 break;
863 case RegClass_kv4_v1_quadReg:
864 KVX_PRINT_REG (KVX_REGFILE_DEC_QGR, value)
865 break;
866 case RegClass_kv4_v1_systemReg:
867 case RegClass_kv4_v1_aloneReg:
868 case RegClass_kv4_v1_onlyraReg:
869 case RegClass_kv4_v1_onlygetReg:
870 case RegClass_kv4_v1_onlysetReg:
871 case RegClass_kv4_v1_onlyfxReg:
872 KVX_PRINT_REG (KVX_REGFILE_DEC_SFR, value)
873 break;
874 case RegClass_kv4_v1_coproReg:
875 case RegClass_kv4_v1_coproReg0M4:
876 case RegClass_kv4_v1_coproReg1M4:
877 case RegClass_kv4_v1_coproReg2M4:
878 case RegClass_kv4_v1_coproReg3M4:
879 KVX_PRINT_REG (KVX_REGFILE_DEC_XCR, value)
880 break;
881 case RegClass_kv4_v1_blockReg:
882 case RegClass_kv4_v1_blockRegE:
883 case RegClass_kv4_v1_blockRegO:
884 KVX_PRINT_REG (KVX_REGFILE_DEC_XBR, value)
885 break;
886 case RegClass_kv4_v1_vectorReg:
887 KVX_PRINT_REG (KVX_REGFILE_DEC_XVR, value)
888 break;
889 case RegClass_kv4_v1_tileReg:
890 KVX_PRINT_REG (KVX_REGFILE_DEC_XTR, value)
891 break;
892 case RegClass_kv4_v1_matrixReg:
893 KVX_PRINT_REG (KVX_REGFILE_DEC_XMR, value)
894 break;
895 case RegClass_kv4_v1_buffer2Reg:
896 KVX_PRINT_REG (KVX_REGFILE_DEC_X2R, value)
897 break;
898 case RegClass_kv4_v1_buffer4Reg:
899 KVX_PRINT_REG (KVX_REGFILE_DEC_X4R, value)
900 break;
901 case RegClass_kv4_v1_buffer8Reg:
902 KVX_PRINT_REG (KVX_REGFILE_DEC_X8R, value)
903 break;
904 case RegClass_kv4_v1_buffer16Reg:
905 KVX_PRINT_REG (KVX_REGFILE_DEC_X16R, value)
906 break;
907 case RegClass_kv4_v1_buffer32Reg:
908 KVX_PRINT_REG (KVX_REGFILE_DEC_X32R, value)
909 break;
910 case RegClass_kv4_v1_buffer64Reg:
911 KVX_PRINT_REG (KVX_REGFILE_DEC_X64R, value)
912 break;
913 case Immediate_kv4_v1_brknumber:
914 case Immediate_kv4_v1_sysnumber:
915 case Immediate_kv4_v1_signed10:
916 case Immediate_kv4_v1_signed16:
917 case Immediate_kv4_v1_signed27:
918 case Immediate_kv4_v1_wrapped32:
919 case Immediate_kv4_v1_signed37:
920 case Immediate_kv4_v1_signed43:
921 case Immediate_kv4_v1_signed54:
922 case Immediate_kv4_v1_wrapped64:
923 case Immediate_kv4_v1_unsigned6:
924 res->operands[idx].val = value;
925 res->operands[idx].sign = flags & kvxSIGNED;
926 res->operands[idx].width = width;
927 res->operands[idx].type = CAT_IMMEDIATE;
928 res->operands[idx].pcrel = 0;
929 idx++;
930 break;
931 case Immediate_kv4_v1_pcrel27:
932 case Immediate_kv4_v1_pcrel17:
933 res->operands[idx].val = value + memaddr;
934 res->operands[idx].sign = flags & kvxSIGNED;
935 res->operands[idx].width = width;
936 res->operands[idx].type = CAT_IMMEDIATE;
937 res->operands[idx].pcrel = 1;
938 idx++;
939 break;
940 case Modifier_kv4_v1_accesses:
941 case Modifier_kv4_v1_boolcas:
942 case Modifier_kv4_v1_cachelev:
943 case Modifier_kv4_v1_channel:
944 case Modifier_kv4_v1_coherency:
945 case Modifier_kv4_v1_comparison:
946 case Modifier_kv4_v1_conjugate:
947 case Modifier_kv4_v1_doscale:
948 case Modifier_kv4_v1_exunum:
949 case Modifier_kv4_v1_floatcomp:
950 case Modifier_kv4_v1_hindex:
951 case Modifier_kv4_v1_lsomask:
952 case Modifier_kv4_v1_lsumask:
953 case Modifier_kv4_v1_lsupack:
954 case Modifier_kv4_v1_qindex:
955 case Modifier_kv4_v1_rounding:
956 case Modifier_kv4_v1_scalarcond:
957 case Modifier_kv4_v1_shuffleV:
958 case Modifier_kv4_v1_shuffleX:
959 case Modifier_kv4_v1_silent:
960 case Modifier_kv4_v1_simplecond:
961 case Modifier_kv4_v1_speculate:
962 case Modifier_kv4_v1_splat32:
963 case Modifier_kv4_v1_transpose:
964 case Modifier_kv4_v1_variant:
965 {
966 int sz = 0;
967 int mod_idx = type - Modifier_kv4_v1_accesses;
968 for (sz = 0; env.kvx_modifiers[mod_idx][sz]; ++sz);
969 const char *mod = value < (unsigned) sz
970 ? env.kvx_modifiers[mod_idx][value] : NULL;
971 if (!mod) goto retry;
972 res->operands[idx].val = value;
973 res->operands[idx].type = CAT_MODIFIER;
974 res->operands[idx].mod_idx = mod_idx;
975 idx++;
976 }
977 break;
978 default:
979 fprintf (stderr, "error: unexpected operand type (%s)\n",
980 type_name);
981 exit (-1);
982 };
983 }
984
985 #undef KVX_PRINT_REG
986 }
987
988 found = 1;
989 break;
990 retry:;
991 idx = 0;
992 continue;
993 }
994 }
995 res->nb_ops = idx;
996 return found;
997 }
998
999 int
1000 print_insn_kvx (bfd_vma memaddr, struct disassemble_info *info)
1001 {
1002 static int insnindex = 0;
1003 static int insncount = 0;
1004 insn_t *insn;
1005 int readsofar = 0;
1006 int found = 0;
1007 int invalid_bundle = 0;
1008
1009 if (!env.initialized_p)
1010 kvx_dis_init (info);
1011
1012 /* Clear instruction information field. */
1013 info->insn_info_valid = 0;
1014 info->branch_delay_insns = 0;
1015 info->data_size = 0;
1016 info->insn_type = dis_noninsn;
1017 info->target = 0;
1018 info->target2 = 0;
1019
1020 /* Set line length. */
1021 info->bytes_per_line = 16;
1022
1023
1024 /* If this is the beginning of the bundle, read BUNDLESIZE words and apply
1025 decentrifugate function. */
1026 if (insnindex == 0)
1027 {
1028 int wordcount;
1029 for (wordcount = 0; wordcount < KVXMAXBUNDLEWORDS; wordcount++)
1030 {
1031 int status;
1032 status =
1033 (*info->read_memory_func) (memaddr + 4 * wordcount,
1034 (bfd_byte *) (bundle_words +
1035 wordcount), 4, info);
1036 if (status != 0)
1037 {
1038 (*info->memory_error_func) (status, memaddr + 4 * wordcount,
1039 info);
1040 return -1;
1041 }
1042 if (!kvx_has_parallel_bit (bundle_words[wordcount]))
1043 break;
1044 }
1045 wordcount++;
1046 invalid_bundle = !kvx_reassemble_bundle (wordcount, &insncount);
1047 }
1048
1049 assert (insnindex < KVXMAXBUNDLEISSUE);
1050 insn = &(bundle_insn[insnindex]);
1051 readsofar = insn->len * 4;
1052 insnindex++;
1053
1054 if (opt_pretty)
1055 {
1056 (*info->fprintf_func) (info->stream, "[ ");
1057 for (int i = 0; i < insn->len; i++)
1058 (*info->fprintf_func) (info->stream, "%08x ", insn->syllables[i]);
1059 (*info->fprintf_func) (info->stream, "] ");
1060 }
1061
1062 /* Check for extension to right iff this is not the end of bundle. */
1063
1064 struct decoded_insn dec;
1065 memset (&dec, 0, sizeof dec);
1066 if (!invalid_bundle && (found = decode_insn (memaddr, insn, &dec)))
1067 {
1068 int ch;
1069 (*info->fprintf_func) (info->stream, "%s", dec.opc->as_op);
1070 const char *fmtp = dec.opc->fmtstring;
1071 for (int i = 0; i < dec.nb_ops; ++i)
1072 {
1073 /* Print characters in the format string up to the following % or nul. */
1074 while ((ch = *fmtp) && ch != '%')
1075 {
1076 (*info->fprintf_func) (info->stream, "%c", ch);
1077 fmtp++;
1078 }
1079
1080 /* Skip past %s. */
1081 if (ch == '%')
1082 {
1083 ch = *fmtp++;
1084 fmtp++;
1085 }
1086
1087 switch (dec.operands[i].type)
1088 {
1089 case CAT_REGISTER:
1090 (*info->fprintf_func) (info->stream, "%s",
1091 env.kvx_registers[dec.operands[i].val].name);
1092 break;
1093 case CAT_MODIFIER:
1094 {
1095 const char *mod = env.kvx_modifiers[dec.operands[i].mod_idx][dec.operands[i].val];
1096 (*info->fprintf_func) (info->stream, "%s", !mod || !strcmp (mod, ".") ? "" : mod);
1097 }
1098 break;
1099 case CAT_IMMEDIATE:
1100 {
1101 if (dec.operands[i].pcrel)
1102 {
1103 /* Fill in instruction information. */
1104 info->insn_info_valid = 1;
1105 info->insn_type =
1106 dec.operands[i].width ==
1107 17 ? dis_condbranch : dis_branch;
1108 info->target = dec.operands[i].val;
1109
1110 info->print_address_func (dec.operands[i].val, info);
1111 }
1112 else if (dec.operands[i].sign)
1113 {
1114 if (dec.operands[i].width <= 32)
1115 {
1116 (*info->fprintf_func) (info->stream, "%" PRId32 " (0x%" PRIx32 ")",
1117 (int32_t) dec.operands[i].val,
1118 (int32_t) dec.operands[i].val);
1119 }
1120 else
1121 {
1122 (*info->fprintf_func) (info->stream, "%" PRId64 " (0x%" PRIx64 ")",
1123 dec.operands[i].val,
1124 dec.operands[i].val);
1125 }
1126 }
1127 else
1128 {
1129 if (dec.operands[i].width <= 32)
1130 {
1131 (*info->fprintf_func) (info->stream, "%" PRIu32 " (0x%" PRIx32 ")",
1132 (uint32_t) dec.operands[i].
1133 val,
1134 (uint32_t) dec.operands[i].
1135 val);
1136 }
1137 else
1138 {
1139 (*info->fprintf_func) (info->stream, "%" PRIu64 " (0x%" PRIx64 ")",
1140 (uint64_t) dec.
1141 operands[i].val,
1142 (uint64_t) dec.
1143 operands[i].val);
1144 }
1145 }
1146 }
1147 break;
1148 default:
1149 break;
1150
1151 }
1152 }
1153
1154 while ((ch = *fmtp))
1155 {
1156 (*info->fprintf_styled_func) (info->stream, dis_style_text, "%c",
1157 ch);
1158 fmtp++;
1159 }
1160 }
1161 else
1162 {
1163 (*info->fprintf_func) (info->stream, "*** invalid opcode ***\n");
1164 insnindex = 0;
1165 readsofar = 4;
1166 }
1167
1168 if (found && (insnindex == insncount))
1169 {
1170 (*info->fprintf_func) (info->stream, ";;");
1171 if (!opt_compact_assembly)
1172 (*info->fprintf_func) (info->stream, "\n");
1173 insnindex = 0;
1174 }
1175
1176 return readsofar;
1177 }
1178
1179 /* This function searches in the current bundle for the instructions required
1180 by unwinding. For prologue:
1181 (1) addd $r12 = $r12, <res_stack>
1182 (2) get <gpr_ra_reg> = $ra
1183 (3) sd <ofs>[$r12] = <gpr_ra_reg> or sq/so containing <gpr_ra_reg>
1184 (4) sd <ofs>[$r12] = $r14 or sq/so containing r14
1185 (5) addd $r14 = $r12, <fp_ofs> or copyd $r14 = $r12
1186 The only difference seen between the code generated by gcc and clang
1187 is the setting/resetting r14. gcc could also generate copyd $r14=$r12
1188 instead of add addd $r14 = $r12, <ofs> when <ofs> is 0.
1189 Vice-versa, <ofs> is not guaranteed to be 0 for clang, so, clang
1190 could also generate addd instead of copyd
1191 (6) call, icall, goto, igoto, cb., ret
1192 For epilogue:
1193 (1) addd $r12 = $r12, <res_stack>
1194 (2) addd $r12 = $r14, <offset> or copyd $r12 = $r14
1195 Same comment as prologue (5).
1196 (3) ret, goto
1197 (4) call, icall, igoto, cb. */
1198
1199 int
1200 decode_prologue_epilogue_bundle (bfd_vma memaddr,
1201 struct disassemble_info *info,
1202 struct kvx_prologue_epilogue_bundle *peb)
1203 {
1204 int i, nb_insn, nb_syl;
1205
1206 peb->nb_insn = 0;
1207
1208 if (info->arch != bfd_arch_kvx)
1209 return -1;
1210
1211 if (!env.initialized_p)
1212 kvx_dis_init (info);
1213
1214 /* Read the bundle. */
1215 for (nb_syl = 0; nb_syl < KVXMAXBUNDLEWORDS; nb_syl++)
1216 {
1217 if ((*info->read_memory_func) (memaddr + 4 * nb_syl,
1218 (bfd_byte *) &bundle_words[nb_syl], 4,
1219 info))
1220 return -1;
1221 if (!kvx_has_parallel_bit (bundle_words[nb_syl]))
1222 break;
1223 }
1224 nb_syl++;
1225 if (!kvx_reassemble_bundle (nb_syl, &nb_insn))
1226 return -1;
1227
1228 /* Check for extension to right if this is not the end of bundle
1229 find the format of this insn. */
1230 for (int idx_insn = 0; idx_insn < nb_insn; idx_insn++)
1231 {
1232 insn_t *insn = &bundle_insn[idx_insn];
1233 int is_add = 0, is_get = 0, is_a_peb_insn = 0, is_copyd = 0;
1234
1235 struct decoded_insn dec;
1236 memset (&dec, 0, sizeof dec);
1237 if (!decode_insn (memaddr, insn, &dec))
1238 continue;
1239
1240 const char *op_name = dec.opc->as_op;
1241 struct kvx_prologue_epilogue_insn *crt_peb_insn;
1242
1243 crt_peb_insn = &peb->insn[peb->nb_insn];
1244 crt_peb_insn->nb_gprs = 0;
1245
1246 if (!strcmp (op_name, "addd"))
1247 is_add = 1;
1248 else if (!strcmp (op_name, "copyd"))
1249 is_copyd = 1;
1250 else if (!strcmp (op_name, "get"))
1251 is_get = 1;
1252 else if (!strcmp (op_name, "sd"))
1253 {
1254 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_SD;
1255 is_a_peb_insn = 1;
1256 }
1257 else if (!strcmp (op_name, "sq"))
1258 {
1259 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_SQ;
1260 is_a_peb_insn = 1;
1261 }
1262 else if (!strcmp (op_name, "so"))
1263 {
1264 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_SO;
1265 is_a_peb_insn = 1;
1266 }
1267 else if (!strcmp (op_name, "ret"))
1268 {
1269 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_RET;
1270 is_a_peb_insn = 1;
1271 }
1272 else if (!strcmp (op_name, "goto"))
1273 {
1274 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_GOTO;
1275 is_a_peb_insn = 1;
1276 }
1277 else if (!strcmp (op_name, "igoto"))
1278 {
1279 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_IGOTO;
1280 is_a_peb_insn = 1;
1281 }
1282 else if (!strcmp (op_name, "call") || !strcmp (op_name, "icall"))
1283 {
1284 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_CALL;
1285 is_a_peb_insn = 1;
1286 }
1287 else if (!strncmp (op_name, "cb", 2))
1288 {
1289 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_CB;
1290 is_a_peb_insn = 1;
1291 }
1292 else
1293 continue;
1294
1295 for (i = 0; dec.opc->format[i]; i++)
1296 {
1297 struct kvx_operand *fmt = dec.opc->format[i];
1298 struct kvx_bitfield *bf = fmt->bfield;
1299 int bf_nb = fmt->bitfields;
1300 int width = fmt->width;
1301 int type = fmt->type;
1302 int flags = fmt->flags;
1303 int shift = fmt->shift;
1304 int bias = fmt->bias;
1305 uint64_t encoded_value, value = 0;
1306
1307 for (int bf_idx = 0; bf_idx < bf_nb; bf_idx++)
1308 {
1309 int insn_idx = (int) bf[bf_idx].to_offset / 32;
1310 int to_offset = bf[bf_idx].to_offset % 32;
1311 encoded_value = insn->syllables[insn_idx] >> to_offset;
1312 encoded_value &= (1LL << bf[bf_idx].size) - 1;
1313 value |= encoded_value << bf[bf_idx].from_offset;
1314 }
1315 if (flags & kvxSIGNED)
1316 {
1317 uint64_t signbit = 1LL << (width - 1);
1318 value = (value ^ signbit) - signbit;
1319 }
1320 value = (value << shift) + bias;
1321
1322 #define chk_type(core_, val_) \
1323 (env.opc_table == kvx_## core_ ##_optab && type == (val_))
1324
1325 if (chk_type (kv3_v1, RegClass_kv3_v1_singleReg)
1326 || chk_type (kv3_v2, RegClass_kv3_v2_singleReg)
1327 || chk_type (kv4_v1, RegClass_kv4_v1_singleReg))
1328 {
1329 if (env.kvx_regfiles[KVX_REGFILE_DEC_GPR] + value
1330 >= env.kvx_max_dec_registers)
1331 return -1;
1332 if (is_add && i < 2)
1333 {
1334 if (i == 0)
1335 {
1336 if (value == KVX_GPR_REG_SP)
1337 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_ADD_SP;
1338 else if (value == KVX_GPR_REG_FP)
1339 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_ADD_FP;
1340 else
1341 is_add = 0;
1342 }
1343 else if (i == 1)
1344 {
1345 if (value == KVX_GPR_REG_SP)
1346 is_a_peb_insn = 1;
1347 else if (value == KVX_GPR_REG_FP
1348 && crt_peb_insn->insn_type
1349 == KVX_PROL_EPIL_INSN_ADD_SP)
1350 {
1351 crt_peb_insn->insn_type
1352 = KVX_PROL_EPIL_INSN_RESTORE_SP_FROM_FP;
1353 is_a_peb_insn = 1;
1354 }
1355 else
1356 is_add = 0;
1357 }
1358 }
1359 else if (is_copyd && i < 2)
1360 {
1361 if (i == 0)
1362 {
1363 if (value == KVX_GPR_REG_FP)
1364 {
1365 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_ADD_FP;
1366 crt_peb_insn->immediate = 0;
1367 }
1368 else if (value == KVX_GPR_REG_SP)
1369 {
1370 crt_peb_insn->insn_type
1371 = KVX_PROL_EPIL_INSN_RESTORE_SP_FROM_FP;
1372 crt_peb_insn->immediate = 0;
1373 }
1374 else
1375 is_copyd = 0;
1376 }
1377 else if (i == 1)
1378 {
1379 if (value == KVX_GPR_REG_SP
1380 && crt_peb_insn->insn_type
1381 == KVX_PROL_EPIL_INSN_ADD_FP)
1382 is_a_peb_insn = 1;
1383 else if (value == KVX_GPR_REG_FP
1384 && crt_peb_insn->insn_type
1385 == KVX_PROL_EPIL_INSN_RESTORE_SP_FROM_FP)
1386 is_a_peb_insn = 1;
1387 else
1388 is_copyd = 0;
1389 }
1390 }
1391 else
1392 crt_peb_insn->gpr_reg[crt_peb_insn->nb_gprs++] = value;
1393 }
1394 else if (chk_type (kv3_v1, RegClass_kv3_v1_pairedReg)
1395 || chk_type (kv3_v2, RegClass_kv3_v2_pairedReg)
1396 || chk_type (kv4_v1, RegClass_kv4_v1_pairedReg))
1397 crt_peb_insn->gpr_reg[crt_peb_insn->nb_gprs++] = value * 2;
1398 else if (chk_type (kv3_v1, RegClass_kv3_v1_quadReg)
1399 || chk_type (kv3_v2, RegClass_kv3_v2_quadReg)
1400 || chk_type (kv4_v1, RegClass_kv4_v1_quadReg))
1401 crt_peb_insn->gpr_reg[crt_peb_insn->nb_gprs++] = value * 4;
1402 else if (chk_type (kv3_v1, RegClass_kv3_v1_systemReg)
1403 || chk_type (kv3_v2, RegClass_kv3_v2_systemReg)
1404 || chk_type (kv4_v1, RegClass_kv4_v1_systemReg)
1405 || chk_type (kv3_v1, RegClass_kv3_v1_aloneReg)
1406 || chk_type (kv3_v2, RegClass_kv3_v2_aloneReg)
1407 || chk_type (kv4_v1, RegClass_kv4_v1_aloneReg)
1408 || chk_type (kv3_v1, RegClass_kv3_v1_onlyraReg)
1409 || chk_type (kv3_v2, RegClass_kv3_v2_onlyraReg)
1410 || chk_type (kv4_v1, RegClass_kv4_v1_onlygetReg)
1411 || chk_type (kv3_v1, RegClass_kv3_v1_onlygetReg)
1412 || chk_type (kv3_v2, RegClass_kv3_v2_onlygetReg)
1413 || chk_type (kv4_v1, RegClass_kv4_v1_onlygetReg)
1414 || chk_type (kv3_v1, RegClass_kv3_v1_onlysetReg)
1415 || chk_type (kv3_v2, RegClass_kv3_v2_onlysetReg)
1416 || chk_type (kv4_v1, RegClass_kv4_v1_onlysetReg)
1417 || chk_type (kv3_v1, RegClass_kv3_v1_onlyfxReg)
1418 || chk_type (kv3_v2, RegClass_kv3_v2_onlyfxReg)
1419 || chk_type (kv4_v1, RegClass_kv4_v1_onlyfxReg))
1420 {
1421 if (env.kvx_regfiles[KVX_REGFILE_DEC_GPR] + value
1422 >= env.kvx_max_dec_registers)
1423 return -1;
1424 if (is_get && !strcmp (env.kvx_registers[env.kvx_dec_registers[env.kvx_regfiles[KVX_REGFILE_DEC_SFR] + value]].name, "$ra"))
1425 {
1426 crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_GET_RA;
1427 is_a_peb_insn = 1;
1428 }
1429 }
1430 else if (chk_type (kv3_v1, RegClass_kv3_v1_coproReg)
1431 || chk_type (kv3_v2, RegClass_kv3_v2_coproReg)
1432 || chk_type (kv4_v1, RegClass_kv4_v1_coproReg)
1433 || chk_type (kv3_v1, RegClass_kv3_v1_blockReg)
1434 || chk_type (kv3_v2, RegClass_kv3_v2_blockReg)
1435 || chk_type (kv4_v1, RegClass_kv4_v1_blockReg)
1436 || chk_type (kv3_v1, RegClass_kv3_v1_vectorReg)
1437 || chk_type (kv3_v2, RegClass_kv3_v2_vectorReg)
1438 || chk_type (kv4_v1, RegClass_kv4_v1_vectorReg)
1439 || chk_type (kv3_v1, RegClass_kv3_v1_tileReg)
1440 || chk_type (kv3_v2, RegClass_kv3_v2_tileReg)
1441 || chk_type (kv4_v1, RegClass_kv4_v1_tileReg)
1442 || chk_type (kv3_v1, RegClass_kv3_v1_matrixReg)
1443 || chk_type (kv3_v2, RegClass_kv3_v2_matrixReg)
1444 || chk_type (kv4_v1, RegClass_kv4_v1_matrixReg)
1445 || chk_type (kv3_v1, Modifier_kv3_v1_scalarcond)
1446 || chk_type (kv3_v1, Modifier_kv3_v1_column)
1447 || chk_type (kv3_v1, Modifier_kv3_v1_comparison)
1448 || chk_type (kv3_v1, Modifier_kv3_v1_doscale)
1449 || chk_type (kv3_v1, Modifier_kv3_v1_exunum)
1450 || chk_type (kv3_v1, Modifier_kv3_v1_floatcomp)
1451 || chk_type (kv3_v1, Modifier_kv3_v1_qindex)
1452 || chk_type (kv3_v1, Modifier_kv3_v1_rectify)
1453 || chk_type (kv3_v1, Modifier_kv3_v1_rounding)
1454 || chk_type (kv3_v1, Modifier_kv3_v1_roundint)
1455 || chk_type (kv3_v1, Modifier_kv3_v1_saturate)
1456 || chk_type (kv3_v1, Modifier_kv3_v1_scalarcond)
1457 || chk_type (kv3_v1, Modifier_kv3_v1_silent)
1458 || chk_type (kv3_v1, Modifier_kv3_v1_simplecond)
1459 || chk_type (kv3_v1, Modifier_kv3_v1_speculate)
1460 || chk_type (kv3_v1, Modifier_kv3_v1_splat32)
1461 || chk_type (kv3_v1, Modifier_kv3_v1_variant)
1462 || chk_type (kv3_v2, Modifier_kv3_v2_accesses)
1463 || chk_type (kv3_v2, Modifier_kv3_v2_boolcas)
1464 || chk_type (kv3_v2, Modifier_kv3_v2_cachelev)
1465 || chk_type (kv3_v2, Modifier_kv3_v2_channel)
1466 || chk_type (kv3_v2, Modifier_kv3_v2_coherency)
1467 || chk_type (kv3_v2, Modifier_kv3_v2_comparison)
1468 || chk_type (kv3_v2, Modifier_kv3_v2_conjugate)
1469 || chk_type (kv3_v2, Modifier_kv3_v2_doscale)
1470 || chk_type (kv3_v2, Modifier_kv3_v2_exunum)
1471 || chk_type (kv3_v2, Modifier_kv3_v2_floatcomp)
1472 || chk_type (kv3_v2, Modifier_kv3_v2_hindex)
1473 || chk_type (kv3_v2, Modifier_kv3_v2_lsomask)
1474 || chk_type (kv3_v2, Modifier_kv3_v2_lsumask)
1475 || chk_type (kv3_v2, Modifier_kv3_v2_lsupack)
1476 || chk_type (kv3_v2, Modifier_kv3_v2_qindex)
1477 || chk_type (kv3_v2, Modifier_kv3_v2_rounding)
1478 || chk_type (kv3_v2, Modifier_kv3_v2_scalarcond)
1479 || chk_type (kv3_v2, Modifier_kv3_v2_shuffleV)
1480 || chk_type (kv3_v2, Modifier_kv3_v2_shuffleX)
1481 || chk_type (kv3_v2, Modifier_kv3_v2_silent)
1482 || chk_type (kv3_v2, Modifier_kv3_v2_simplecond)
1483 || chk_type (kv3_v2, Modifier_kv3_v2_speculate)
1484 || chk_type (kv3_v2, Modifier_kv3_v2_splat32)
1485 || chk_type (kv3_v2, Modifier_kv3_v2_transpose)
1486 || chk_type (kv3_v2, Modifier_kv3_v2_variant)
1487 || chk_type (kv4_v1, Modifier_kv4_v1_accesses)
1488 || chk_type (kv4_v1, Modifier_kv4_v1_boolcas)
1489 || chk_type (kv4_v1, Modifier_kv4_v1_cachelev)
1490 || chk_type (kv4_v1, Modifier_kv4_v1_channel)
1491 || chk_type (kv4_v1, Modifier_kv4_v1_coherency)
1492 || chk_type (kv4_v1, Modifier_kv4_v1_comparison)
1493 || chk_type (kv4_v1, Modifier_kv4_v1_conjugate)
1494 || chk_type (kv4_v1, Modifier_kv4_v1_doscale)
1495 || chk_type (kv4_v1, Modifier_kv4_v1_exunum)
1496 || chk_type (kv4_v1, Modifier_kv4_v1_floatcomp)
1497 || chk_type (kv4_v1, Modifier_kv4_v1_hindex)
1498 || chk_type (kv4_v1, Modifier_kv4_v1_lsomask)
1499 || chk_type (kv4_v1, Modifier_kv4_v1_lsumask)
1500 || chk_type (kv4_v1, Modifier_kv4_v1_lsupack)
1501 || chk_type (kv4_v1, Modifier_kv4_v1_qindex)
1502 || chk_type (kv4_v1, Modifier_kv4_v1_rounding)
1503 || chk_type (kv4_v1, Modifier_kv4_v1_scalarcond)
1504 || chk_type (kv4_v1, Modifier_kv4_v1_shuffleV)
1505 || chk_type (kv4_v1, Modifier_kv4_v1_shuffleX)
1506 || chk_type (kv4_v1, Modifier_kv4_v1_silent)
1507 || chk_type (kv4_v1, Modifier_kv4_v1_simplecond)
1508 || chk_type (kv4_v1, Modifier_kv4_v1_speculate)
1509 || chk_type (kv4_v1, Modifier_kv4_v1_splat32)
1510 || chk_type (kv4_v1, Modifier_kv4_v1_transpose)
1511 || chk_type (kv4_v1, Modifier_kv4_v1_variant))
1512 {
1513 /* Do nothing. */
1514 }
1515 else if (chk_type (kv3_v1, Immediate_kv3_v1_sysnumber)
1516 || chk_type (kv3_v2, Immediate_kv3_v2_sysnumber)
1517 || chk_type (kv4_v1, Immediate_kv4_v1_sysnumber)
1518 || chk_type (kv3_v2, Immediate_kv3_v2_wrapped8)
1519 || chk_type (kv4_v1, Immediate_kv4_v1_wrapped8)
1520 || chk_type (kv3_v1, Immediate_kv3_v1_signed10)
1521 || chk_type (kv3_v2, Immediate_kv3_v2_signed10)
1522 || chk_type (kv4_v1, Immediate_kv4_v1_signed10)
1523 || chk_type (kv3_v1, Immediate_kv3_v1_signed16)
1524 || chk_type (kv3_v2, Immediate_kv3_v2_signed16)
1525 || chk_type (kv4_v1, Immediate_kv4_v1_signed16)
1526 || chk_type (kv3_v1, Immediate_kv3_v1_signed27)
1527 || chk_type (kv3_v2, Immediate_kv3_v2_signed27)
1528 || chk_type (kv4_v1, Immediate_kv4_v1_signed27)
1529 || chk_type (kv3_v1, Immediate_kv3_v1_wrapped32)
1530 || chk_type (kv3_v2, Immediate_kv3_v2_wrapped32)
1531 || chk_type (kv4_v1, Immediate_kv4_v1_wrapped32)
1532 || chk_type (kv3_v1, Immediate_kv3_v1_signed37)
1533 || chk_type (kv3_v2, Immediate_kv3_v2_signed37)
1534 || chk_type (kv4_v1, Immediate_kv4_v1_signed37)
1535 || chk_type (kv3_v1, Immediate_kv3_v1_signed43)
1536 || chk_type (kv3_v2, Immediate_kv3_v2_signed43)
1537 || chk_type (kv4_v1, Immediate_kv4_v1_signed43)
1538 || chk_type (kv3_v1, Immediate_kv3_v1_signed54)
1539 || chk_type (kv3_v2, Immediate_kv3_v2_signed54)
1540 || chk_type (kv4_v1, Immediate_kv4_v1_signed54)
1541 || chk_type (kv3_v1, Immediate_kv3_v1_wrapped64)
1542 || chk_type (kv3_v2, Immediate_kv3_v2_wrapped64)
1543 || chk_type (kv4_v1, Immediate_kv4_v1_wrapped64)
1544 || chk_type (kv3_v1, Immediate_kv3_v1_unsigned6)
1545 || chk_type (kv3_v2, Immediate_kv3_v2_unsigned6)
1546 || chk_type (kv4_v1, Immediate_kv4_v1_unsigned6))
1547 crt_peb_insn->immediate = value;
1548 else if (chk_type (kv3_v1, Immediate_kv3_v1_pcrel17)
1549 || chk_type (kv3_v2, Immediate_kv3_v2_pcrel17)
1550 || chk_type (kv4_v1, Immediate_kv4_v1_pcrel17)
1551 || chk_type (kv3_v1, Immediate_kv3_v1_pcrel27)
1552 || chk_type (kv3_v2, Immediate_kv3_v2_pcrel27)
1553 || chk_type (kv4_v1, Immediate_kv4_v1_pcrel27))
1554 crt_peb_insn->immediate = value + memaddr;
1555 else
1556 return -1;
1557 }
1558
1559 if (is_a_peb_insn)
1560 peb->nb_insn++;
1561 continue;
1562 }
1563
1564 return nb_syl * 4;
1565 #undef chk_type
1566 }
1567
1568 void
1569 print_kvx_disassembler_options (FILE * stream)
1570 {
1571 fprintf (stream, _("\n\
1572 The following KVX specific disassembler options are supported for use\n\
1573 with the -M switch (multiple options should be separated by commas):\n"));
1574
1575 fprintf (stream, _("\n\
1576 pretty Print 32-bit words in natural order corresponding to \
1577 re-ordered instruction.\n"));
1578
1579 fprintf (stream, _("\n\
1580 compact-assembly Do not emit a new line between bundles of instructions.\
1581 \n"));
1582
1583 fprintf (stream, _("\n\
1584 no-compact-assembly Emit a new line between bundles of instructions.\n"));
1585
1586 fprintf (stream, _("\n"));
1587 }
The GNU Binutils are a collection of binary tools.