Automatic date update in version.in
[binutils-gdb.git] / opcodes / aarch64-gen.c
blobbcee1a317e82d776ece565814c1518dfbafa18cf
1 /* aarch64-gen.c -- Generate tables and routines for opcode lookup and
2 instruction encoding and decoding.
3 Copyright (C) 2012-2022 Free Software Foundation, Inc.
4 Contributed by ARM Ltd.
6 This file is part of the GNU opcodes library.
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; see the file COPYING3. If not,
20 see <http://www.gnu.org/licenses/>. */
22 #include "sysdep.h"
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
27 #include "libiberty.h"
28 #include "getopt.h"
29 #include "opcode/aarch64.h"
31 #define VERIFIER(x) NULL
32 #include "aarch64-tbl.h"
34 static int debug = 0;
36 /* Structure used in the decoding tree to group a list of aarch64_opcode
37 entries. */
39 struct opcode_node
41 aarch64_insn opcode;
42 aarch64_insn mask;
43 /* Index of the entry in the original table; the top 2 bits help
44 determine the table. */
45 unsigned int index;
46 struct opcode_node *next;
49 typedef struct opcode_node opcode_node;
51 /* Head of the list of the opcode_node after read_table. */
52 static opcode_node opcode_nodes_head;
54 /* Node in the decoding tree. */
56 struct bittree
58 unsigned int bitno;
59 /* 0, 1, and X (don't care). */
60 struct bittree *bits[2];
61 /* List of opcodes; only valid for the leaf node. */
62 opcode_node *list;
65 /* Allocate and initialize an opcode_node. */
66 static opcode_node*
67 new_opcode_node (void)
69 opcode_node* ent = malloc (sizeof (opcode_node));
71 if (!ent)
72 abort ();
74 ent->opcode = 0;
75 ent->mask = 0;
76 ent->index = -1;
77 ent->next = NULL;
79 return ent;
82 /* Multiple tables are supported, although currently only one table is
83 in use. N.B. there are still some functions have the table name
84 'aarch64_opcode_table' hard-coded in, e.g. print_find_next_opcode;
85 therefore some amount of work needs to be done if the full support
86 for multiple tables needs to be enabled. */
87 static const struct aarch64_opcode * const aarch64_opcode_tables[] =
88 {aarch64_opcode_table};
90 /* Use top 2 bits to indiate which table. */
91 static unsigned int
92 initialize_index (const struct aarch64_opcode* table)
94 int i;
95 const int num_of_tables = sizeof (aarch64_opcode_tables)
96 / sizeof (struct aarch64_opcode *);
97 for (i = 0; i < num_of_tables; ++i)
98 if (table == aarch64_opcode_tables [i])
99 break;
100 if (i == num_of_tables)
101 abort ();
102 return (unsigned int)i << 30;
105 static inline const struct aarch64_opcode *
106 index2table (unsigned int index)
108 return aarch64_opcode_tables[(index >> 30) & 0x3];
111 static inline unsigned int
112 real_index (unsigned int index)
114 return index & ((1 << 30) - 1);
117 /* Given OPCODE_NODE, return the corresponding aarch64_opcode*. */
118 static const aarch64_opcode*
119 get_aarch64_opcode (const opcode_node *opcode_node)
121 if (opcode_node == NULL)
122 return NULL;
123 return &index2table (opcode_node->index)[real_index (opcode_node->index)];
126 static void
127 read_table (const struct aarch64_opcode* table)
129 const struct aarch64_opcode *ent = table;
130 opcode_node **new_ent;
131 unsigned int index = initialize_index (table);
133 if (!ent->name)
134 return;
136 new_ent = &opcode_nodes_head.next;
138 while (*new_ent)
139 new_ent = &(*new_ent)->next;
143 /* F_PSEUDO needs to be used together with F_ALIAS to indicate an alias
144 opcode is a programmer friendly pseudo instruction available only in
145 the assembly code (thus will not show up in the disassembly). */
146 assert (!pseudo_opcode_p (ent) || alias_opcode_p (ent));
147 /* Skip alias (inc. pseudo) opcode. */
148 if (alias_opcode_p (ent))
150 index++;
151 continue;
153 *new_ent = new_opcode_node ();
154 (*new_ent)->opcode = ent->opcode;
155 (*new_ent)->mask = ent->mask;
156 (*new_ent)->index = index++;
157 new_ent = &((*new_ent)->next);
158 } while ((++ent)->name);
161 static inline void
162 print_one_opcode_node (opcode_node* ent)
164 printf ("%s\t%08x\t%08x\t%d\n", get_aarch64_opcode (ent)->name,
165 get_aarch64_opcode (ent)->opcode, get_aarch64_opcode (ent)->mask,
166 (int)real_index (ent->index));
169 /* As an internal debugging utility, print out the list of nodes pointed
170 by opcode_nodes_head. */
171 static void
172 print_opcode_nodes (void)
174 opcode_node* ent = opcode_nodes_head.next;
175 printf ("print_opcode_nodes table:\n");
176 while (ent)
178 print_one_opcode_node (ent);
179 ent = ent->next;
183 static struct bittree*
184 new_bittree_node (void)
186 struct bittree* node;
187 node = malloc (sizeof (struct bittree));
188 if (!node)
189 abort ();
190 node->bitno = -1;
191 node->bits[0] = NULL;
192 node->bits[1] = NULL;
193 return node;
196 /* The largest number of opcode entries that exist at a leaf node of the
197 decoding decision tree. The reason that there can be more than one
198 opcode entry is because some opcodes have shared field that is partially
199 constrained and thus cannot be fully isolated using the algorithm
200 here. */
201 static int max_num_opcodes_at_leaf_node = 0;
203 /* Given a list of opcodes headed by *OPCODE, try to establish one bit that
204 is shared by all the opcodes in the list as one of base opcode bits. If
205 such a bit is found, divide the list of the opcodes into two based on the
206 value of the bit.
208 Store the bit number in BITTREE->BITNO if the division succeeds. If unable
209 to determine such a bit or there is only one opcode in the list, the list
210 is decided to be undividable and OPCODE will be assigned to BITTREE->LIST.
212 The function recursively call itself until OPCODE is undividable.
214 N.B. the nature of this algrithm determines that given any value in the
215 32-bit space, the computed decision tree will always be able to find one or
216 more opcodes entries for it, regardless whether there is a valid instruction
217 defined for this value or not. In order to detect the undefined values,
218 when the caller obtains the opcode entry/entries, it should at least compare
219 the bit-wise AND result of the value and the mask with the base opcode
220 value; if the two are different, it means that the value is undefined
221 (although the value may be still undefined when the comparison is the same,
222 in which case call aarch64_opcode_decode to carry out further checks). */
224 static void
225 divide_table_1 (struct bittree *bittree, opcode_node *opcode)
227 aarch64_insn mask_and;
228 opcode_node *ent;
229 unsigned int bitno;
230 aarch64_insn bitmask;
231 opcode_node list0, list1, **ptr0, **ptr1;
232 static int depth = 0;
234 ++depth;
236 if (debug)
237 printf ("Enter into depth %d\n", depth);
239 assert (opcode != NULL);
241 /* Succeed when there is only one opcode left. */
242 if (!opcode->next)
244 if (debug)
246 printf ("opcode isolated:\n");
247 print_one_opcode_node (opcode);
249 goto divide_table_1_finish;
252 divide_table_1_try_again:
253 mask_and = -1;
254 ent = opcode;
255 while (ent)
257 mask_and &= ent->mask;
258 ent = ent->next;
261 if (debug)
262 printf ("mask and result: %08x\n", (unsigned int)mask_and);
264 /* If no more bit to look into, we have to accept the reality then. */
265 if (!mask_and)
267 int i;
268 opcode_node *ptr;
269 if (debug)
271 ptr = opcode;
272 printf ("Isolated opcode group:\n");
273 do {
274 print_one_opcode_node (ptr);
275 ptr = ptr->next;
276 } while (ptr);
278 /* Count the number of opcodes. */
279 for (i = 0, ptr = opcode; ptr; ++i)
280 ptr = ptr->next;
281 if (i > max_num_opcodes_at_leaf_node)
282 max_num_opcodes_at_leaf_node = i;
283 goto divide_table_1_finish;
286 /* Pick up the right most bit that is 1. */
287 bitno = 0;
288 while (!(mask_and & (1 << bitno)))
289 ++bitno;
290 bitmask = (1 << bitno);
292 if (debug)
293 printf ("use bit %d\n", bitno);
295 /* Record in the bittree. */
296 bittree->bitno = bitno;
298 /* Get two new opcode lists; adjust their masks. */
299 list0.next = NULL;
300 list1.next = NULL;
301 ptr0 = &list0.next;
302 ptr1 = &list1.next;
303 ent = opcode;
304 while (ent)
306 if (ent->opcode & bitmask)
308 ent->mask &= (~bitmask);
309 *ptr1 = ent;
310 ent = ent->next;
311 (*ptr1)->next = NULL;
312 ptr1 = &(*ptr1)->next;
314 else
316 ent->mask &= (~bitmask);
317 *ptr0 = ent;
318 ent = ent->next;
319 (*ptr0)->next = NULL;
320 ptr0 = &(*ptr0)->next;
324 /* If BITNO can NOT divide the opcode group, try next bit. */
325 if (list0.next == NULL)
327 opcode = list1.next;
328 goto divide_table_1_try_again;
330 else if (list1.next == NULL)
332 opcode = list0.next;
333 goto divide_table_1_try_again;
336 /* Further divide. */
337 bittree->bits[0] = new_bittree_node ();
338 bittree->bits[1] = new_bittree_node ();
339 divide_table_1 (bittree->bits[0], list0.next);
340 divide_table_1 (bittree->bits[1], list1.next);
342 divide_table_1_finish:
343 if (debug)
344 printf ("Leave from depth %d\n", depth);
345 --depth;
347 /* Record the opcode entries on this leaf node. */
348 bittree->list = opcode;
350 return;
353 /* Call divide_table_1 to divide the all the opcodes and thus create the
354 decoding decision tree. */
355 static struct bittree *
356 divide_table (void)
358 struct bittree *bittree = new_bittree_node ();
359 divide_table_1 (bittree, opcode_nodes_head.next);
360 return bittree;
363 /* Read in all of the tables, create the decoding decision tree and return
364 the tree root. */
365 static struct bittree *
366 initialize_decoder_tree (void)
368 int i;
369 const int num_of_tables = (sizeof (aarch64_opcode_tables)
370 / sizeof (struct aarch64_opcode *));
371 for (i = 0; i < num_of_tables; ++i)
372 read_table (aarch64_opcode_tables [i]);
373 if (debug)
374 print_opcode_nodes ();
375 return divide_table ();
378 static void __attribute__ ((format (printf, 2, 3)))
379 indented_print (unsigned int indent, const char *format, ...)
381 va_list ap;
382 va_start (ap, format);
383 printf ("%*s", (int) indent, "");
384 vprintf (format, ap);
385 va_end (ap);
388 /* N.B. read the comment above divide_table_1 for the reason why the generated
389 decision tree function never returns NULL. */
391 static void
392 print_decision_tree_1 (unsigned int indent, struct bittree* bittree)
394 /* PATTERN is only used to generate comment in the code. */
395 static char pattern[33] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
396 /* Low bits in PATTERN will be printed first which then look as the high
397 bits in comment. We need to reverse the index to get correct print. */
398 unsigned int msb = sizeof (pattern) - 2;
399 assert (bittree != NULL);
401 /* Leaf node located. */
402 if (bittree->bits[0] == NULL && bittree->bits[1] == NULL)
404 assert (bittree->list != NULL);
405 indented_print (indent, "/* 33222222222211111111110000000000\n");
406 indented_print (indent, " 10987654321098765432109876543210\n");
407 indented_print (indent, " %s\n", pattern);
408 indented_print (indent, " %s. */\n",
409 get_aarch64_opcode (bittree->list)->name);
410 indented_print (indent, "return %u;\n",
411 real_index (bittree->list->index));
412 return;
415 /* Walk down the decoder tree. */
416 indented_print (indent, "if (((word >> %d) & 0x1) == 0)\n", bittree->bitno);
417 indented_print (indent, " {\n");
418 pattern[msb - bittree->bitno] = '0';
419 print_decision_tree_1 (indent + 4, bittree->bits[0]);
420 indented_print (indent, " }\n");
421 indented_print (indent, "else\n");
422 indented_print (indent, " {\n");
423 pattern[msb - bittree->bitno] = '1';
424 print_decision_tree_1 (indent + 4, bittree->bits[1]);
425 indented_print (indent, " }\n");
426 pattern[msb - bittree->bitno] = 'x';
429 /* Generate aarch64_opcode_lookup in C code to the standard output. */
431 static void
432 print_decision_tree (struct bittree* bittree)
434 if (debug)
435 printf ("Enter print_decision_tree\n");
437 printf ("/* Called by aarch64_opcode_lookup. */\n\n");
439 printf ("static int\n");
440 printf ("aarch64_opcode_lookup_1 (uint32_t word)\n");
441 printf ("{\n");
443 print_decision_tree_1 (2, bittree);
445 printf ("}\n\n");
448 printf ("/* Lookup opcode WORD in the opcode table. N.B. all alias\n");
449 printf (" opcodes are ignored here. */\n\n");
451 printf ("const aarch64_opcode *\n");
452 printf ("aarch64_opcode_lookup (uint32_t word)\n");
453 printf ("{\n");
454 printf (" return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);\n");
455 printf ("}\n");
458 static void
459 print_find_next_opcode_1 (struct bittree* bittree)
461 assert (bittree != NULL);
463 /* Leaf node located. */
464 if (bittree->bits[0] == NULL && bittree->bits[1] == NULL)
466 assert (bittree->list != NULL);
467 /* Find multiple opcode entries in one leaf node. */
468 if (bittree->list->next != NULL)
470 opcode_node *list = bittree->list;
471 while (list != NULL)
473 const aarch64_opcode *curr = get_aarch64_opcode (list);
474 const aarch64_opcode *next = get_aarch64_opcode (list->next);
476 printf (" case %u: ",
477 (unsigned int)(curr - aarch64_opcode_table));
478 if (list->next != NULL)
480 printf ("value = %u; break;\t", real_index (list->next->index));
481 printf ("/* %s --> %s. */\n", curr->name, next->name);
483 else
485 printf ("return NULL;\t\t");
486 printf ("/* %s --> NULL. */\n", curr->name);
489 list = list->next;
492 return;
495 /* Walk down the decoder tree. */
496 print_find_next_opcode_1 (bittree->bits[0]);
497 print_find_next_opcode_1 (bittree->bits[1]);
500 /* Generate aarch64_find_next_opcode in C code to the standard output. */
502 static void
503 print_find_next_opcode (struct bittree* bittree)
505 if (debug)
506 printf ("Enter print_find_next_opcode\n");
508 printf ("\n");
509 printf ("const aarch64_opcode *\n");
510 printf ("aarch64_find_next_opcode (const aarch64_opcode *opcode)\n");
511 printf ("{\n");
512 printf (" /* Use the index as the key to locate the next opcode. */\n");
513 printf (" int key = opcode - aarch64_opcode_table;\n");
514 printf (" int value;\n");
515 printf (" switch (key)\n");
516 printf (" {\n");
518 print_find_next_opcode_1 (bittree);
520 printf (" default: return NULL;\n");
521 printf (" }\n\n");
523 printf (" return aarch64_opcode_table + value;\n");
524 printf ("}\n");
527 /* Release the dynamic memory resource allocated for the generation of the
528 decoder tree. */
530 static void
531 release_resource_decoder_tree (struct bittree* bittree)
533 assert (bittree != NULL);
535 /* Leaf node located. */
536 if (bittree->bits[0] == NULL && bittree->bits[1] == NULL)
538 assert (bittree->list != NULL);
539 /* Free opcode_nodes. */
540 opcode_node *list = bittree->list;
541 while (list != NULL)
543 opcode_node *next = list->next;
544 free (list);
545 list = next;
547 /* Free the tree node. */
548 free (bittree);
549 return;
552 /* Walk down the decoder tree. */
553 release_resource_decoder_tree (bittree->bits[0]);
554 release_resource_decoder_tree (bittree->bits[1]);
556 /* Free the tree node. */
557 free (bittree);
560 /* Generate aarch64_find_real_opcode in C code to the standard output.
561 TABLE points to the alias info table, while NUM indicates the number of
562 entries in the table. */
564 static void
565 print_find_real_opcode (const opcode_node *table, int num)
567 int i;
569 if (debug)
570 printf ("Enter print_find_real_opcode\n");
572 printf ("\n");
573 printf ("const aarch64_opcode *\n");
574 printf ("aarch64_find_real_opcode (const aarch64_opcode *opcode)\n");
575 printf ("{\n");
576 printf (" /* Use the index as the key to locate the real opcode. */\n");
577 printf (" int key = opcode - aarch64_opcode_table;\n");
578 printf (" int value;\n");
579 printf (" switch (key)\n");
580 printf (" {\n");
582 for (i = 0; i < num; ++i)
584 const opcode_node *real = table + i;
585 const opcode_node *alias = real->next;
586 for (; alias; alias = alias->next)
587 printf (" case %u:\t/* %s */\n", real_index (alias->index),
588 get_aarch64_opcode (alias)->name);
589 printf (" value = %u;\t/* --> %s. */\n", real_index (real->index),
590 get_aarch64_opcode (real)->name);
591 printf (" break;\n");
594 printf (" default: return NULL;\n");
595 printf (" }\n\n");
597 printf (" return aarch64_opcode_table + value;\n");
598 printf ("}\n");
601 /* Generate aarch64_find_alias_opcode in C code to the standard output.
602 TABLE points to the alias info table, while NUM indicates the number of
603 entries in the table. */
605 static void
606 print_find_alias_opcode (const opcode_node *table, int num)
608 int i;
610 if (debug)
611 printf ("Enter print_find_alias_opcode\n");
613 printf ("\n");
614 printf ("const aarch64_opcode *\n");
615 printf ("aarch64_find_alias_opcode (const aarch64_opcode *opcode)\n");
616 printf ("{\n");
617 printf (" /* Use the index as the key to locate the alias opcode. */\n");
618 printf (" int key = opcode - aarch64_opcode_table;\n");
619 printf (" int value;\n");
620 printf (" switch (key)\n");
621 printf (" {\n");
623 for (i = 0; i < num; ++i)
625 const opcode_node *node = table + i;
626 assert (node->next);
627 printf (" case %u: value = %u; break;", real_index (node->index),
628 real_index (node->next->index));
629 printf ("\t/* %s --> %s. */\n", get_aarch64_opcode (node)->name,
630 get_aarch64_opcode (node->next)->name);
633 printf (" default: return NULL;\n");
634 printf (" }\n\n");
636 printf (" return aarch64_opcode_table + value;\n");
637 printf ("}\n");
640 /* Generate aarch64_find_next_alias_opcode in C code to the standard output.
641 TABLE points to the alias info table, while NUM indicates the number of
642 entries in the table. */
644 static void
645 print_find_next_alias_opcode (const opcode_node *table, int num)
647 int i;
649 if (debug)
650 printf ("Enter print_find_next_alias_opcode\n");
652 printf ("\n");
653 printf ("const aarch64_opcode *\n");
654 printf ("aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)\n");
655 printf ("{\n");
656 printf (" /* Use the index as the key to locate the next opcode. */\n");
657 printf (" int key = opcode - aarch64_opcode_table;\n");
658 printf (" int value;\n");
659 printf (" switch (key)\n");
660 printf (" {\n");
662 for (i = 0; i < num; ++i)
664 const opcode_node *node = table + i;
665 assert (node->next);
666 if (node->next->next == NULL)
667 continue;
668 while (node->next->next)
670 printf (" case %u: value = %u; break;", real_index (node->next->index),
671 real_index (node->next->next->index));
672 printf ("\t/* %s --> %s. */\n",
673 get_aarch64_opcode (node->next)->name,
674 get_aarch64_opcode (node->next->next)->name);
675 node = node->next;
679 printf (" default: return NULL;\n");
680 printf (" }\n\n");
682 printf (" return aarch64_opcode_table + value;\n");
683 printf ("}\n");
686 /* Given OPCODE, establish and return a link list of alias nodes in the
687 preferred order. */
689 opcode_node *
690 find_alias_opcode (const aarch64_opcode *opcode)
692 int i;
693 /* Assume maximum of 32 disassemble preference candidates. */
694 const int max_num_aliases = 32;
695 const aarch64_opcode *ent;
696 const aarch64_opcode *preferred[max_num_aliases + 1];
697 opcode_node head, **next;
699 assert (opcode_has_alias (opcode));
701 i = 0;
702 if (opcode->name != NULL)
703 preferred[i++] = opcode;
704 ent = aarch64_opcode_table;
705 while (ent->name != NULL)
707 /* The mask of an alias opcode must be equal to or a super-set (i.e.
708 more constrained) of that of the aliased opcode; so is the base
709 opcode value. */
710 if (alias_opcode_p (ent)
711 && (ent->mask & opcode->mask) == opcode->mask
712 && (opcode->mask & ent->opcode) == (opcode->mask & opcode->opcode))
714 assert (i < max_num_aliases);
715 preferred[i++] = ent;
716 if (debug)
717 printf ("found %s for %s.", ent->name, opcode->name);
719 ++ent;
722 if (debug)
724 int m;
725 printf ("un-orderd list: ");
726 for (m = 0; m < i; ++m)
727 printf ("%s, ", preferred[m]->name);
728 printf ("\n");
731 /* There must be at least one alias. */
732 assert (i >= 1);
734 /* Sort preferred array according to the priority (from the lowest to the
735 highest. */
736 if (i > 1)
738 int j, k;
739 for (j = 0; j < i - 1; ++j)
741 for (k = 0; k < i - 1 - j; ++k)
743 const aarch64_opcode *t;
744 t = preferred [k+1];
745 if (opcode_priority (t) < opcode_priority (preferred [k]))
747 preferred [k+1] = preferred [k];
748 preferred [k] = t;
754 if (debug)
756 int m;
757 printf ("orderd list: ");
758 for (m = 0; m < i; ++m)
759 printf ("%s, ", preferred[m]->name);
760 printf ("\n");
763 /* Create a link-list of opcode_node with disassemble preference from
764 higher to lower. */
765 next = &head.next;
766 --i;
767 while (i >= 0)
769 const aarch64_opcode *alias = preferred [i];
770 opcode_node *node = new_opcode_node ();
772 if (debug)
773 printf ("add %s.\n", alias->name);
775 node->index = alias - aarch64_opcode_table;
776 *next = node;
777 next = &node->next;
779 --i;
781 *next = NULL;
783 return head.next;
786 /* Create and return alias information.
787 Return the address of the created alias info table; return the number
788 of table entries in *NUM_PTR. */
790 opcode_node *
791 create_alias_info (int *num_ptr)
793 int i, num;
794 opcode_node *ret;
795 const aarch64_opcode *ent;
797 /* Calculate the total number of opcodes that have alias. */
798 num = 0;
799 ent = aarch64_opcode_table;
800 while (ent->name != NULL)
802 if (opcode_has_alias (ent))
804 /* Assert the alias relationship be flat-structured to keep
805 algorithms simple; not allow F_ALIAS and F_HAS_ALIAS both
806 specified. */
807 assert (!alias_opcode_p (ent));
808 ++num;
810 ++ent;
812 assert (num_ptr);
813 *num_ptr = num;
815 /* The array of real opcodes that have alias(es). */
816 ret = malloc (sizeof (opcode_node) * num);
818 /* For each opcode, establish a list of alias nodes in a preferred
819 order. */
820 for (i = 0, ent = aarch64_opcode_table; i < num; ++i, ++ent)
822 opcode_node *node = ret + i;
823 while (ent->name != NULL && !opcode_has_alias (ent))
824 ++ent;
825 assert (ent->name != NULL);
826 node->index = ent - aarch64_opcode_table;
827 node->next = find_alias_opcode (ent);
828 assert (node->next);
830 assert (i == num);
832 return ret;
835 /* Release the dynamic memory resource allocated for the generation of the
836 alias information. */
838 void
839 release_resource_alias_info (opcode_node *alias_info, int num)
841 int i = 0;
842 opcode_node *node = alias_info;
844 /* Free opcode_node list. */
845 for (; i < num; ++i, ++node)
847 opcode_node *list = node->next;
850 opcode_node *next = list->next;
851 free (list);
852 list = next;
853 } while (list != NULL);
856 /* Free opcode_node array. */
857 free (alias_info);
860 /* As a debugging utility, print out the result of the table division, although
861 it is not doing much this moment. */
862 static void
863 print_divide_result (const struct bittree *bittree ATTRIBUTE_UNUSED)
865 printf ("max_num_opcodes_at_leaf_node: %d\n", max_num_opcodes_at_leaf_node);
866 return;
869 /* Structure to help generate the operand table. */
870 struct operand
872 const char *class;
873 const char *inserter;
874 const char *extractor;
875 const char *str;
876 const char *flags;
877 const char *fields;
878 const char *desc;
879 unsigned processed : 1;
880 unsigned has_inserter : 1;
881 unsigned has_extractor : 1;
884 typedef struct operand operand;
886 #ifdef X
887 #undef X
888 #endif
890 #ifdef Y
891 #undef Y
892 #endif
894 #ifdef F
895 #undef F
896 #endif
898 /* Get the operand information in strings. */
900 static operand operands[] =
902 {"NIL", "0", "0", "", "0", "{0}", "<none>", 0, 0, 0},
903 #define F(...) #__VA_ARGS__
904 #define X(a,b,c,d,e,f,g) \
905 {#a, #b, #c, d, #e, "{"f"}", g, 0, 0, 0},
906 #define Y(a,b,d,e,f,g) \
907 {#a, "ins_"#b, "ext_"#b, d, #e, "{"f"}", g, 0, 0, 0},
908 AARCH64_OPERANDS
909 {"NIL", "0", "0", "", "0", "{0}", "DUMMY", 0, 0, 0},
912 #undef F
913 #undef X
915 static void
916 process_operand_table (void)
918 int i;
919 operand *opnd;
920 const int num = sizeof (operands) / sizeof (operand);
922 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
924 opnd->has_inserter = opnd->inserter[0] != '0';
925 opnd->has_extractor = opnd->extractor[0] != '0';
929 /* Generate aarch64_operands in C to the standard output. */
931 static void
932 print_operand_table (void)
934 int i;
935 operand *opnd;
936 const int num = sizeof (operands) / sizeof (operand);
938 if (debug)
939 printf ("Enter print_operand_table\n");
941 printf ("\n");
942 printf ("const struct aarch64_operand aarch64_operands[] =\n");
943 printf ("{\n");
945 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
947 char flags[256];
948 flags[0] = '\0';
949 if (opnd->flags[0] != '0')
950 sprintf (flags, "%s", opnd->flags);
951 if (opnd->has_inserter)
953 if (flags[0] != '\0')
954 strcat (flags, " | ");
955 strcat (flags, "OPD_F_HAS_INSERTER");
957 if (opnd->has_extractor)
959 if (flags[0] != '\0')
960 strcat (flags, " | ");
961 strcat (flags, "OPD_F_HAS_EXTRACTOR");
963 if (flags[0] == '\0')
965 flags[0] = '0';
966 flags[1] = '\0';
968 printf (" {AARCH64_OPND_CLASS_%s, \"%s\", %s, %s, \"%s\"},\n",
969 opnd->class, opnd->str, flags, opnd->fields, opnd->desc);
971 printf ("};\n");
974 /* Generate aarch64_insert_operand in C to the standard output. */
976 static void
977 print_operand_inserter (void)
979 int i;
980 operand *opnd;
981 const int num = sizeof (operands) / sizeof (operand);
983 if (debug)
984 printf ("Enter print_operand_inserter\n");
986 printf ("\n");
987 printf ("bool\n");
988 printf ("aarch64_insert_operand (const aarch64_operand *self,\n\
989 const aarch64_opnd_info *info,\n\
990 aarch64_insn *code, const aarch64_inst *inst,\n\
991 aarch64_operand_error *errors)\n");
992 printf ("{\n");
993 printf (" /* Use the index as the key. */\n");
994 printf (" int key = self - aarch64_operands;\n");
995 printf (" switch (key)\n");
996 printf (" {\n");
998 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
999 opnd->processed = 0;
1001 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
1003 if (!opnd->processed && opnd->has_inserter)
1005 int j = i + 1;
1006 const int len = strlen (opnd->inserter);
1007 operand *opnd2 = opnd + 1;
1008 printf (" case %u:\n", (unsigned int)(opnd - operands));
1009 opnd->processed = 1;
1010 for (; j < num; ++j, ++opnd2)
1012 if (!opnd2->processed
1013 && opnd2->has_inserter
1014 && len == strlen (opnd2->inserter)
1015 && strncmp (opnd->inserter, opnd2->inserter, len) == 0)
1017 printf (" case %u:\n", (unsigned int)(opnd2 - operands));
1018 opnd2->processed = 1;
1021 printf (" return aarch64_%s (self, info, code, inst, errors);\n",
1022 opnd->inserter);
1026 printf (" default: assert (0); abort ();\n");
1027 printf (" }\n");
1028 printf ("}\n");
1031 /* Generate aarch64_extract_operand in C to the standard output. */
1033 static void
1034 print_operand_extractor (void)
1036 int i;
1037 operand *opnd;
1038 const int num = sizeof (operands) / sizeof (operand);
1040 if (debug)
1041 printf ("Enter print_operand_extractor\n");
1043 printf ("\n");
1044 printf ("bool\n");
1045 printf ("aarch64_extract_operand (const aarch64_operand *self,\n\
1046 aarch64_opnd_info *info,\n\
1047 aarch64_insn code, const aarch64_inst *inst,\n\
1048 aarch64_operand_error *errors)\n");
1049 printf ("{\n");
1050 printf (" /* Use the index as the key. */\n");
1051 printf (" int key = self - aarch64_operands;\n");
1052 printf (" switch (key)\n");
1053 printf (" {\n");
1055 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
1056 opnd->processed = 0;
1058 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
1060 if (!opnd->processed && opnd->has_extractor)
1062 int j = i + 1;
1063 const int len = strlen (opnd->extractor);
1064 operand *opnd2 = opnd + 1;
1065 printf (" case %u:\n", (unsigned int)(opnd - operands));
1066 opnd->processed = 1;
1067 for (; j < num; ++j, ++opnd2)
1069 if (!opnd2->processed
1070 && opnd2->has_extractor
1071 && len == strlen (opnd2->extractor)
1072 && strncmp (opnd->extractor, opnd2->extractor, len) == 0)
1074 printf (" case %u:\n", (unsigned int)(opnd2 - operands));
1075 opnd2->processed = 1;
1078 printf (" return aarch64_%s (self, info, code, inst, errors);\n",
1079 opnd->extractor);
1083 printf (" default: assert (0); abort ();\n");
1084 printf (" }\n");
1085 printf ("}\n");
1088 /* Table indexed by opcode enumerator stores the index of the corresponding
1089 opcode entry in aarch64_opcode_table. */
1090 static unsigned op_enum_table [OP_TOTAL_NUM];
1092 /* Print out the routine which, given the opcode enumerator, returns the
1093 corresponding opcode entry pointer. */
1095 static void
1096 print_get_opcode (void)
1098 int i;
1099 const int num = OP_TOTAL_NUM;
1100 const aarch64_opcode *opcode;
1102 if (debug)
1103 printf ("Enter print_get_opcode\n");
1105 /* Fill in the internal table. */
1106 opcode = aarch64_opcode_table;
1107 while (opcode->name != NULL)
1109 if (opcode->op != OP_NIL)
1111 /* Assert opcode enumerator be unique, in other words, no shared by
1112 different opcodes. */
1113 if (op_enum_table[opcode->op] != 0)
1115 fprintf (stderr, "Opcode %u is shared by different %s and %s.\n",
1116 opcode->op,
1117 aarch64_opcode_table[op_enum_table[opcode->op]].name,
1118 opcode->name);
1119 assert (0);
1120 abort ();
1122 assert (opcode->op < OP_TOTAL_NUM);
1123 op_enum_table[opcode->op] = opcode - aarch64_opcode_table;
1125 ++opcode;
1128 /* Print the table. */
1129 printf ("\n");
1130 printf ("/* Indexed by an enum aarch64_op enumerator, the value is the offset of\n\
1131 the corresponding aarch64_opcode entry in the aarch64_opcode_table. */\n\n");
1132 printf ("static const unsigned op_enum_table [] =\n");
1133 printf ("{\n");
1134 for (i = 0; i < num; ++i)
1135 printf (" %u,\n", op_enum_table[i]);
1136 printf ("};\n");
1138 /* Print the function. */
1139 printf ("\n");
1140 printf ("/* Given the opcode enumerator OP, return the pointer to the corresponding\n");
1141 printf (" opcode entry. */\n");
1142 printf ("\n");
1143 printf ("const aarch64_opcode *\n");
1144 printf ("aarch64_get_opcode (enum aarch64_op op)\n");
1145 printf ("{\n");
1146 printf (" return aarch64_opcode_table + op_enum_table[op];\n");
1147 printf ("}\n");
1150 /* Print out the content of an opcode table (not in use). */
1151 static void ATTRIBUTE_UNUSED
1152 print_table (struct aarch64_opcode* table)
1154 struct aarch64_opcode *ent = table;
1157 printf ("%s\t%08x\t%08x\n", ent->name, (unsigned int)ent->opcode,
1158 (unsigned int)ent->mask);
1159 } while ((++ent)->name);
1162 static const char * program_name = NULL;
1164 /* Program options. */
1165 struct option long_options[] =
1167 {"debug", no_argument, NULL, 'd'},
1168 {"version", no_argument, NULL, 'V'},
1169 {"help", no_argument, NULL, 'h'},
1170 {"gen-opc", no_argument, NULL, 'c'},
1171 {"gen-asm", no_argument, NULL, 'a'},
1172 {"gen-dis", no_argument, NULL, 's'},
1173 {0, no_argument, NULL, 0}
1176 static void
1177 print_version (void)
1179 printf ("%s: version 1.0\n", program_name);
1180 xexit (0);
1183 static void
1184 usage (FILE * stream, int status)
1186 fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--help]\n",
1187 program_name);
1188 fprintf (stream, "\t[ [-c | --gen-opc] | [-a | --gen-asm] | [-s | --gen-dis] ]\n");
1189 xexit (status);
1193 main (int argc, char **argv)
1195 extern int chdir (char *);
1196 int c;
1197 int gen_opcode_p = 0;
1198 int gen_assembler_p = 0;
1199 int gen_disassembler_p = 0;
1201 program_name = *argv;
1202 xmalloc_set_program_name (program_name);
1204 while ((c = getopt_long (argc, argv, "vVdhacs", long_options, 0)) != EOF)
1205 switch (c)
1207 case 'V':
1208 case 'v':
1209 print_version ();
1210 break;
1211 case 'd':
1212 debug = 1;
1213 break;
1214 case 'h':
1215 case '?':
1216 usage (stderr, 0);
1217 break;
1218 case 'c':
1219 gen_opcode_p = 1;
1220 break;
1221 case 'a':
1222 gen_assembler_p = 1;
1223 break;
1224 case 's':
1225 gen_disassembler_p = 1;
1226 break;
1227 default:
1228 case 0:
1229 break;
1232 if (argc == 1 || optind != argc)
1233 usage (stdout, 1);
1235 if (gen_opcode_p + gen_assembler_p + gen_disassembler_p > 1)
1237 printf ("Please specify only one of the following options\n\
1238 [-c | --gen-opc] [-a | --gen-asm] [-s | --gen-dis]\n");
1239 xexit (2);
1242 struct bittree *decoder_tree;
1244 decoder_tree = initialize_decoder_tree ();
1245 if (debug)
1246 print_divide_result (decoder_tree);
1248 printf ("/* This file is automatically generated by aarch64-gen. Do not edit! */\n");
1249 printf ("/* Copyright (C) 2012-2022 Free Software Foundation, Inc.\n\
1250 Contributed by ARM Ltd.\n\
1252 This file is part of the GNU opcodes library.\n\
1254 This library is free software; you can redistribute it and/or modify\n\
1255 it under the terms of the GNU General Public License as published by\n\
1256 the Free Software Foundation; either version 3, or (at your option)\n\
1257 any later version.\n\
1259 It is distributed in the hope that it will be useful, but WITHOUT\n\
1260 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
1261 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\
1262 License for more details.\n\
1264 You should have received a copy of the GNU General Public License\n\
1265 along with this program; see the file COPYING3. If not,\n\
1266 see <http://www.gnu.org/licenses/>. */\n");
1268 printf ("\n");
1269 printf ("#include \"sysdep.h\"\n");
1270 if (gen_opcode_p)
1271 printf ("#include \"aarch64-opc.h\"\n");
1272 if (gen_assembler_p)
1273 printf ("#include \"aarch64-asm.h\"\n");
1274 if (gen_disassembler_p)
1275 printf ("#include \"aarch64-dis.h\"\n");
1276 printf ("\n");
1278 /* Generate opcode entry lookup for the disassembler. */
1279 if (gen_disassembler_p)
1281 print_decision_tree (decoder_tree);
1282 print_find_next_opcode (decoder_tree);
1283 release_resource_decoder_tree (decoder_tree);
1286 /* Generate alias opcode handling for the assembler or the disassembler. */
1287 if (gen_assembler_p || gen_disassembler_p)
1289 int num;
1290 opcode_node *alias_info = create_alias_info (&num);
1292 if (gen_assembler_p)
1293 print_find_real_opcode (alias_info, num);
1295 if (gen_disassembler_p)
1297 print_find_alias_opcode (alias_info, num);
1298 print_find_next_alias_opcode (alias_info, num);
1301 release_resource_alias_info (alias_info, num);
1304 /* Generate operand table. */
1305 process_operand_table ();
1307 if (gen_assembler_p)
1308 print_operand_inserter ();
1310 if (gen_disassembler_p)
1311 print_operand_extractor ();
1313 if (gen_opcode_p)
1314 print_operand_table ();
1316 /* Generate utility to return aarch64_opcode entry given an enumerator. */
1317 if (gen_opcode_p)
1318 print_get_opcode ();
1320 exit (0);