1 /* aarch64-gen.c -- Generate tables and routines for opcode lookup and
2 instruction encoding and decoding.
3 Copyright (C) 2012-2017 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)
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/>. */
27 #include "libiberty.h"
29 #include "opcode/aarch64.h"
31 #define VERIFIER(x) NULL
32 #include "aarch64-tbl.h"
36 /* Structure used in the decoding tree to group a list of aarch64_opcode
43 /* Index of the entry in the original table; the top 2 bits help
44 determine the table. */
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. */
59 /* 0, 1, and X (don't care). */
60 struct bittree *bits[2];
61 /* List of opcodes; only valid for the leaf node. */
65 /* Allocate and initialize an opcode_node. */
67 new_opcode_node (void)
69 opcode_node* ent = malloc (sizeof (opcode_node));
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 *aarch64_opcode_tables[] =
88 {aarch64_opcode_table};
90 /* Use top 2 bits to indiate which table. */
92 initialize_index (const struct aarch64_opcode* table)
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])
100 if (i == num_of_tables)
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)
123 return &index2table (opcode_node->index)[real_index (opcode_node->index)];
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);
136 new_ent = &opcode_nodes_head.next;
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))
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);
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. */
172 print_opcode_nodes (void)
174 opcode_node* ent = opcode_nodes_head.next;
175 printf ("print_opcode_nodes table:\n");
178 print_one_opcode_node (ent);
183 static struct bittree*
184 new_bittree_node (void)
186 struct bittree* node;
187 node = malloc (sizeof (struct bittree));
191 node->bits[0] = NULL;
192 node->bits[1] = NULL;
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
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
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). */
225 divide_table_1 (struct bittree *bittree, opcode_node *opcode)
227 aarch64_insn mask_and;
230 aarch64_insn bitmask;
231 opcode_node list0, list1, **ptr0, **ptr1;
232 static int depth = 0;
237 printf ("Enter into depth %d\n", depth);
239 assert (opcode != NULL);
241 /* Succeed when there is only one opcode left. */
246 printf ("opcode isolated:\n");
247 print_one_opcode_node (opcode);
249 goto divide_table_1_finish;
252 divide_table_1_try_again:
257 mask_and &= ent->mask;
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. */
272 printf ("Isolated opcode group:\n");
274 print_one_opcode_node (ptr);
278 /* Count the number of opcodes. */
279 for (i = 0, ptr = opcode; ptr; ++i)
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. */
288 while (!(mask_and & (1 << bitno)))
290 bitmask = (1 << bitno);
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. */
306 if (ent->opcode & bitmask)
308 ent->mask &= (~bitmask);
311 (*ptr1)->next = NULL;
312 ptr1 = &(*ptr1)->next;
316 ent->mask &= (~bitmask);
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)
328 goto divide_table_1_try_again;
330 else if (list1.next == NULL)
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:
344 printf ("Leave from depth %d\n", depth);
347 /* Record the opcode entries on this leaf node. */
348 bittree->list = opcode;
353 /* Call divide_table_1 to divide the all the opcodes and thus create the
354 decoding decision tree. */
355 static struct bittree *
358 struct bittree *bittree = new_bittree_node ();
359 divide_table_1 (bittree, opcode_nodes_head.next);
363 /* Read in all of the tables, create the decoding decision tree and return
365 static struct bittree *
366 initialize_decoder_tree (void)
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]);
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, ...)
382 va_start (ap, format);
383 printf ("%*s", (int) indent, "");
384 vprintf (format, ap);
388 /* N.B. read the comment above divide_table_1 for the reason why the generated
389 decision tree function never returns NULL. */
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 assert (bittree != NULL);
398 /* Leaf node located. */
399 if (bittree->bits[0] == NULL && bittree->bits[1] == NULL)
401 assert (bittree->list != NULL);
402 indented_print (indent, "/* 33222222222211111111110000000000\n");
403 indented_print (indent, " 10987654321098765432109876543210\n");
404 indented_print (indent, " %s\n", pattern);
405 indented_print (indent, " %s. */\n",
406 get_aarch64_opcode (bittree->list)->name);
407 indented_print (indent, "return %u;\n",
408 real_index (bittree->list->index));
412 /* Walk down the decoder tree. */
413 indented_print (indent, "if (((word >> %d) & 0x1) == 0)\n", bittree->bitno);
414 indented_print (indent, " {\n");
415 pattern[bittree->bitno] = '0';
416 print_decision_tree_1 (indent + 4, bittree->bits[0]);
417 indented_print (indent, " }\n");
418 indented_print (indent, "else\n");
419 indented_print (indent, " {\n");
420 pattern[bittree->bitno] = '1';
421 print_decision_tree_1 (indent + 4, bittree->bits[1]);
422 indented_print (indent, " }\n");
423 pattern[bittree->bitno] = 'x';
426 /* Generate aarch64_opcode_lookup in C code to the standard output. */
429 print_decision_tree (struct bittree* bittree)
432 printf ("Enter print_decision_tree\n");
434 printf ("/* Called by aarch64_opcode_lookup. */\n\n");
436 printf ("static int\n");
437 printf ("aarch64_opcode_lookup_1 (uint32_t word)\n");
440 print_decision_tree_1 (2, bittree);
445 printf ("/* Lookup opcode WORD in the opcode table. N.B. all alias\n");
446 printf (" opcodes are ignored here. */\n\n");
448 printf ("const aarch64_opcode *\n");
449 printf ("aarch64_opcode_lookup (uint32_t word)\n");
451 printf (" return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);\n");
456 print_find_next_opcode_1 (struct bittree* bittree)
458 assert (bittree != NULL);
460 /* Leaf node located. */
461 if (bittree->bits[0] == NULL && bittree->bits[1] == NULL)
463 assert (bittree->list != NULL);
464 /* Find multiple opcode entries in one leaf node. */
465 if (bittree->list->next != NULL)
467 opcode_node *list = bittree->list;
470 const aarch64_opcode *curr = get_aarch64_opcode (list);
471 const aarch64_opcode *next = get_aarch64_opcode (list->next);
473 printf (" case %u: ",
474 (unsigned int)(curr - aarch64_opcode_table));
475 if (list->next != NULL)
477 printf ("value = %u; break;\t", real_index (list->next->index));
478 printf ("/* %s --> %s. */\n", curr->name, next->name);
482 printf ("return NULL;\t\t");
483 printf ("/* %s --> NULL. */\n", curr->name);
492 /* Walk down the decoder tree. */
493 print_find_next_opcode_1 (bittree->bits[0]);
494 print_find_next_opcode_1 (bittree->bits[1]);
497 /* Generate aarch64_find_next_opcode in C code to the standard output. */
500 print_find_next_opcode (struct bittree* bittree)
503 printf ("Enter print_find_next_opcode\n");
506 printf ("const aarch64_opcode *\n");
507 printf ("aarch64_find_next_opcode (const aarch64_opcode *opcode)\n");
509 printf (" /* Use the index as the key to locate the next opcode. */\n");
510 printf (" int key = opcode - aarch64_opcode_table;\n");
511 printf (" int value;\n");
512 printf (" switch (key)\n");
515 print_find_next_opcode_1 (bittree);
517 printf (" default: return NULL;\n");
520 printf (" return aarch64_opcode_table + value;\n");
524 /* Release the dynamic memory resource allocated for the generation of the
528 release_resource_decoder_tree (struct bittree* bittree)
530 assert (bittree != NULL);
532 /* Leaf node located. */
533 if (bittree->bits[0] == NULL && bittree->bits[1] == NULL)
535 assert (bittree->list != NULL);
536 /* Free opcode_nodes. */
537 opcode_node *list = bittree->list;
540 opcode_node *next = list->next;
544 /* Free the tree node. */
549 /* Walk down the decoder tree. */
550 release_resource_decoder_tree (bittree->bits[0]);
551 release_resource_decoder_tree (bittree->bits[1]);
553 /* Free the tree node. */
557 /* Generate aarch64_find_real_opcode in C code to the standard output.
558 TABLE points to the alias info table, while NUM indicates the number of
559 entries in the table. */
562 print_find_real_opcode (const opcode_node *table, int num)
567 printf ("Enter print_find_real_opcode\n");
570 printf ("const aarch64_opcode *\n");
571 printf ("aarch64_find_real_opcode (const aarch64_opcode *opcode)\n");
573 printf (" /* Use the index as the key to locate the real opcode. */\n");
574 printf (" int key = opcode - aarch64_opcode_table;\n");
575 printf (" int value;\n");
576 printf (" switch (key)\n");
579 for (i = 0; i < num; ++i)
581 const opcode_node *real = table + i;
582 const opcode_node *alias = real->next;
583 for (; alias; alias = alias->next)
584 printf (" case %u:\t/* %s */\n", real_index (alias->index),
585 get_aarch64_opcode (alias)->name);
586 printf (" value = %u;\t/* --> %s. */\n", real_index (real->index),
587 get_aarch64_opcode (real)->name);
588 printf (" break;\n");
591 printf (" default: return NULL;\n");
594 printf (" return aarch64_opcode_table + value;\n");
598 /* Generate aarch64_find_alias_opcode in C code to the standard output.
599 TABLE points to the alias info table, while NUM indicates the number of
600 entries in the table. */
603 print_find_alias_opcode (const opcode_node *table, int num)
608 printf ("Enter print_find_alias_opcode\n");
611 printf ("const aarch64_opcode *\n");
612 printf ("aarch64_find_alias_opcode (const aarch64_opcode *opcode)\n");
614 printf (" /* Use the index as the key to locate the alias opcode. */\n");
615 printf (" int key = opcode - aarch64_opcode_table;\n");
616 printf (" int value;\n");
617 printf (" switch (key)\n");
620 for (i = 0; i < num; ++i)
622 const opcode_node *node = table + i;
624 printf (" case %u: value = %u; break;", real_index (node->index),
625 real_index (node->next->index));
626 printf ("\t/* %s --> %s. */\n", get_aarch64_opcode (node)->name,
627 get_aarch64_opcode (node->next)->name);
630 printf (" default: return NULL;\n");
633 printf (" return aarch64_opcode_table + value;\n");
637 /* Generate aarch64_find_next_alias_opcode in C code to the standard output.
638 TABLE points to the alias info table, while NUM indicates the number of
639 entries in the table. */
642 print_find_next_alias_opcode (const opcode_node *table, int num)
647 printf ("Enter print_find_next_alias_opcode\n");
650 printf ("const aarch64_opcode *\n");
651 printf ("aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)\n");
653 printf (" /* Use the index as the key to locate the next opcode. */\n");
654 printf (" int key = opcode - aarch64_opcode_table;\n");
655 printf (" int value;\n");
656 printf (" switch (key)\n");
659 for (i = 0; i < num; ++i)
661 const opcode_node *node = table + i;
663 if (node->next->next == NULL)
665 while (node->next->next)
667 printf (" case %u: value = %u; break;", real_index (node->next->index),
668 real_index (node->next->next->index));
669 printf ("\t/* %s --> %s. */\n",
670 get_aarch64_opcode (node->next)->name,
671 get_aarch64_opcode (node->next->next)->name);
676 printf (" default: return NULL;\n");
679 printf (" return aarch64_opcode_table + value;\n");
683 /* Given OPCODE, establish and return a link list of alias nodes in the
687 find_alias_opcode (const aarch64_opcode *opcode)
690 /* Assume maximum of 32 disassemble preference candidates. */
691 const int max_num_aliases = 32;
692 const aarch64_opcode *ent;
693 const aarch64_opcode *preferred[max_num_aliases + 1];
694 opcode_node head, **next;
696 assert (opcode_has_alias (opcode));
699 if (opcode->name != NULL)
700 preferred[i++] = opcode;
701 ent = aarch64_opcode_table;
702 while (ent->name != NULL)
704 /* The mask of an alias opcode must be equal to or a super-set (i.e.
705 more constrained) of that of the aliased opcode; so is the base
707 if (alias_opcode_p (ent)
708 && (ent->mask & opcode->mask) == opcode->mask
709 && (opcode->mask & ent->opcode) == (opcode->mask & opcode->opcode))
711 assert (i < max_num_aliases);
712 preferred[i++] = ent;
714 printf ("found %s for %s.", ent->name, opcode->name);
722 printf ("un-orderd list: ");
723 for (m = 0; m < i; ++m)
724 printf ("%s, ", preferred[m]->name);
728 /* There must be at least one alias. */
731 /* Sort preferred array according to the priority (from the lowest to the
736 for (j = 0; j < i - 1; ++j)
738 for (k = 0; k < i - 1 - j; ++k)
740 const aarch64_opcode *t;
742 if (opcode_priority (t) < opcode_priority (preferred [k]))
744 preferred [k+1] = preferred [k];
754 printf ("orderd list: ");
755 for (m = 0; m < i; ++m)
756 printf ("%s, ", preferred[m]->name);
760 /* Create a link-list of opcode_node with disassemble preference from
766 const aarch64_opcode *alias = preferred [i];
767 opcode_node *node = new_opcode_node ();
770 printf ("add %s.\n", alias->name);
772 node->index = alias - aarch64_opcode_table;
783 /* Create and return alias information.
784 Return the address of the created alias info table; return the number
785 of table entries in *NUM_PTR. */
788 create_alias_info (int *num_ptr)
792 const aarch64_opcode *ent;
794 /* Calculate the total number of opcodes that have alias. */
796 ent = aarch64_opcode_table;
797 while (ent->name != NULL)
799 if (opcode_has_alias (ent))
801 /* Assert the alias relationship be flat-structured to keep
802 algorithms simple; not allow F_ALIAS and F_HAS_ALIAS both
804 assert (!alias_opcode_p (ent));
812 /* The array of real opcodes that have alias(es). */
813 ret = malloc (sizeof (opcode_node) * num);
815 /* For each opcode, establish a list of alias nodes in a preferred
817 for (i = 0, ent = aarch64_opcode_table; i < num; ++i, ++ent)
819 opcode_node *node = ret + i;
820 while (ent->name != NULL && !opcode_has_alias (ent))
822 assert (ent->name != NULL);
823 node->index = ent - aarch64_opcode_table;
824 node->next = find_alias_opcode (ent);
832 /* Release the dynamic memory resource allocated for the generation of the
833 alias information. */
836 release_resource_alias_info (opcode_node *alias_info, int num)
839 opcode_node *node = alias_info;
841 /* Free opcode_node list. */
842 for (; i < num; ++i, ++node)
844 opcode_node *list = node->next;
847 opcode_node *next = list->next;
850 } while (list != NULL);
853 /* Free opcode_node array. */
857 /* As a debugging utility, print out the result of the table division, although
858 it is not doing much this moment. */
860 print_divide_result (const struct bittree *bittree ATTRIBUTE_UNUSED)
862 printf ("max_num_opcodes_at_leaf_node: %d\n", max_num_opcodes_at_leaf_node);
866 /* Structure to help generate the operand table. */
870 const char *inserter;
871 const char *extractor;
876 unsigned processed : 1;
877 unsigned has_inserter : 1;
878 unsigned has_extractor : 1;
881 typedef struct operand operand;
895 /* Get the operand information in strings. */
897 static operand operands[] =
899 {"NIL", "0", "0", "", "0", "{0}", "<none>", 0, 0, 0},
900 #define F(...) #__VA_ARGS__
901 #define X(a,b,c,d,e,f,g) \
902 {#a, #b, #c, d, #e, "{"f"}", g, 0, 0, 0},
903 #define Y(a,b,d,e,f,g) \
904 {#a, "ins_"#b, "ext_"#b, d, #e, "{"f"}", g, 0, 0, 0},
906 {"NIL", "0", "0", "", "0", "{0}", "DUMMY", 0, 0, 0},
913 process_operand_table (void)
917 const int num = sizeof (operands) / sizeof (operand);
919 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
921 opnd->has_inserter = opnd->inserter[0] != '0';
922 opnd->has_extractor = opnd->extractor[0] != '0';
926 /* Generate aarch64_operands in C to the standard output. */
929 print_operand_table (void)
933 const int num = sizeof (operands) / sizeof (operand);
936 printf ("Enter print_operand_table\n");
939 printf ("const struct aarch64_operand aarch64_operands[] =\n");
942 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
946 if (opnd->flags[0] != '0')
947 sprintf (flags, "%s", opnd->flags);
948 if (opnd->has_inserter)
950 if (flags[0] != '\0')
951 strcat (flags, " | ");
952 strcat (flags, "OPD_F_HAS_INSERTER");
954 if (opnd->has_extractor)
956 if (flags[0] != '\0')
957 strcat (flags, " | ");
958 strcat (flags, "OPD_F_HAS_EXTRACTOR");
960 if (flags[0] == '\0')
965 printf (" {AARCH64_OPND_CLASS_%s, \"%s\", %s, %s, \"%s\"},\n",
966 opnd->class, opnd->str, flags, opnd->fields, opnd->desc);
971 /* Generate aarch64_insert_operand in C to the standard output. */
974 print_operand_inserter (void)
978 const int num = sizeof (operands) / sizeof (operand);
981 printf ("Enter print_operand_inserter\n");
984 printf ("const char*\n");
985 printf ("aarch64_insert_operand (const aarch64_operand *self,\n\
986 const aarch64_opnd_info *info,\n\
987 aarch64_insn *code, const aarch64_inst *inst)\n");
989 printf (" /* Use the index as the key. */\n");
990 printf (" int key = self - aarch64_operands;\n");
991 printf (" switch (key)\n");
994 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
997 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
999 if (!opnd->processed && opnd->has_inserter)
1002 const int len = strlen (opnd->inserter);
1003 operand *opnd2 = opnd + 1;
1004 printf (" case %u:\n", (unsigned int)(opnd - operands));
1005 opnd->processed = 1;
1006 for (; j < num; ++j, ++opnd2)
1008 if (!opnd2->processed
1009 && opnd2->has_inserter
1010 && len == strlen (opnd2->inserter)
1011 && strncmp (opnd->inserter, opnd2->inserter, len) == 0)
1013 printf (" case %u:\n", (unsigned int)(opnd2 - operands));
1014 opnd2->processed = 1;
1017 printf (" return aarch64_%s (self, info, code, inst);\n",
1022 printf (" default: assert (0); abort ();\n");
1027 /* Generate aarch64_extract_operand in C to the standard output. */
1030 print_operand_extractor (void)
1034 const int num = sizeof (operands) / sizeof (operand);
1037 printf ("Enter print_operand_extractor\n");
1041 printf ("aarch64_extract_operand (const aarch64_operand *self,\n\
1042 aarch64_opnd_info *info,\n\
1043 aarch64_insn code, const aarch64_inst *inst)\n");
1045 printf (" /* Use the index as the key. */\n");
1046 printf (" int key = self - aarch64_operands;\n");
1047 printf (" switch (key)\n");
1050 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
1051 opnd->processed = 0;
1053 for (i = 0, opnd = operands; i < num; ++i, ++opnd)
1055 if (!opnd->processed && opnd->has_extractor)
1058 const int len = strlen (opnd->extractor);
1059 operand *opnd2 = opnd + 1;
1060 printf (" case %u:\n", (unsigned int)(opnd - operands));
1061 opnd->processed = 1;
1062 for (; j < num; ++j, ++opnd2)
1064 if (!opnd2->processed
1065 && opnd2->has_extractor
1066 && len == strlen (opnd2->extractor)
1067 && strncmp (opnd->extractor, opnd2->extractor, len) == 0)
1069 printf (" case %u:\n", (unsigned int)(opnd2 - operands));
1070 opnd2->processed = 1;
1073 printf (" return aarch64_%s (self, info, code, inst);\n",
1078 printf (" default: assert (0); abort ();\n");
1083 /* Table indexed by opcode enumerator stores the index of the corresponding
1084 opcode entry in aarch64_opcode_table. */
1085 static unsigned op_enum_table [OP_TOTAL_NUM];
1087 /* Print out the routine which, given the opcode enumerator, returns the
1088 corresponding opcode entry pointer. */
1091 print_get_opcode (void)
1094 const int num = OP_TOTAL_NUM;
1095 const aarch64_opcode *opcode;
1098 printf ("Enter print_get_opcode\n");
1100 /* Fill in the internal table. */
1101 opcode = aarch64_opcode_table;
1102 while (opcode->name != NULL)
1104 if (opcode->op != OP_NIL)
1106 /* Assert opcode enumerator be unique, in other words, no shared by
1107 different opcodes. */
1108 if (op_enum_table[opcode->op] != 0)
1110 fprintf (stderr, "Opcode %u is shared by different %s and %s.\n",
1112 aarch64_opcode_table[op_enum_table[opcode->op]].name,
1117 assert (opcode->op < OP_TOTAL_NUM);
1118 op_enum_table[opcode->op] = opcode - aarch64_opcode_table;
1123 /* Print the table. */
1125 printf ("/* Indexed by an enum aarch64_op enumerator, the value is the offset of\n\
1126 the corresponding aarch64_opcode entry in the aarch64_opcode_table. */\n\n");
1127 printf ("static const unsigned op_enum_table [] =\n");
1129 for (i = 0; i < num; ++i)
1130 printf (" %u,\n", op_enum_table[i]);
1133 /* Print the function. */
1135 printf ("/* Given the opcode enumerator OP, return the pointer to the corresponding\n");
1136 printf (" opcode entry. */\n");
1138 printf ("const aarch64_opcode *\n");
1139 printf ("aarch64_get_opcode (enum aarch64_op op)\n");
1141 printf (" return aarch64_opcode_table + op_enum_table[op];\n");
1145 /* Print out the content of an opcode table (not in use). */
1146 static void ATTRIBUTE_UNUSED
1147 print_table (struct aarch64_opcode* table)
1149 struct aarch64_opcode *ent = table;
1152 printf ("%s\t%08x\t%08x\n", ent->name, (unsigned int)ent->opcode,
1153 (unsigned int)ent->mask);
1154 } while ((++ent)->name);
1157 static const char * program_name = NULL;
1159 /* Program options. */
1160 struct option long_options[] =
1162 {"debug", no_argument, NULL, 'd'},
1163 {"version", no_argument, NULL, 'V'},
1164 {"help", no_argument, NULL, 'h'},
1165 {"gen-opc", no_argument, NULL, 'c'},
1166 {"gen-asm", no_argument, NULL, 'a'},
1167 {"gen-dis", no_argument, NULL, 's'},
1168 {0, no_argument, NULL, 0}
1172 print_version (void)
1174 printf ("%s: version 1.0\n", program_name);
1179 usage (FILE * stream, int status)
1181 fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--help]\n",
1183 fprintf (stream, "\t[ [-c | --gen-opc] | [-a | --gen-asm] | [-s | --gen-dis] ]\n");
1188 main (int argc, char **argv)
1190 extern int chdir (char *);
1192 int gen_opcode_p = 0;
1193 int gen_assembler_p = 0;
1194 int gen_disassembler_p = 0;
1196 program_name = *argv;
1197 xmalloc_set_program_name (program_name);
1199 while ((c = getopt_long (argc, argv, "vVdhacs", long_options, 0)) != EOF)
1217 gen_assembler_p = 1;
1220 gen_disassembler_p = 1;
1227 if (argc == 1 || optind != argc)
1230 if (gen_opcode_p + gen_assembler_p + gen_disassembler_p > 1)
1232 printf ("Please specify only one of the following options\n\
1233 [-c | --gen-opc] [-a | --gen-asm] [-s | --gen-dis]\n");
1237 struct bittree *decoder_tree;
1239 decoder_tree = initialize_decoder_tree ();
1241 print_divide_result (decoder_tree);
1243 printf ("/* This file is automatically generated by aarch64-gen. Do not edit! */\n");
1244 printf ("/* Copyright (C) 2012-2017 Free Software Foundation, Inc.\n\
1245 Contributed by ARM Ltd.\n\
1247 This file is part of the GNU opcodes library.\n\
1249 This library is free software; you can redistribute it and/or modify\n\
1250 it under the terms of the GNU General Public License as published by\n\
1251 the Free Software Foundation; either version 3, or (at your option)\n\
1252 any later version.\n\
1254 It is distributed in the hope that it will be useful, but WITHOUT\n\
1255 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
1256 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\
1257 License for more details.\n\
1259 You should have received a copy of the GNU General Public License\n\
1260 along with this program; see the file COPYING3. If not,\n\
1261 see <http://www.gnu.org/licenses/>. */\n");
1264 printf ("#include \"sysdep.h\"\n");
1266 printf ("#include \"aarch64-opc.h\"\n");
1267 if (gen_assembler_p)
1268 printf ("#include \"aarch64-asm.h\"\n");
1269 if (gen_disassembler_p)
1270 printf ("#include \"aarch64-dis.h\"\n");
1273 /* Generate opcode entry lookup for the disassembler. */
1274 if (gen_disassembler_p)
1276 print_decision_tree (decoder_tree);
1277 print_find_next_opcode (decoder_tree);
1278 release_resource_decoder_tree (decoder_tree);
1281 /* Generate alias opcode handling for the assembler or the disassembler. */
1282 if (gen_assembler_p || gen_disassembler_p)
1285 opcode_node *alias_info = create_alias_info (&num);
1287 if (gen_assembler_p)
1288 print_find_real_opcode (alias_info, num);
1290 if (gen_disassembler_p)
1292 print_find_alias_opcode (alias_info, num);
1293 print_find_next_alias_opcode (alias_info, num);
1296 release_resource_alias_info (alias_info, num);
1299 /* Generate operand table. */
1300 process_operand_table ();
1302 if (gen_assembler_p)
1303 print_operand_inserter ();
1305 if (gen_disassembler_p)
1306 print_operand_extractor ();
1309 print_operand_table ();
1311 /* Generate utility to return aarch64_opcode entry given an enumerator. */
1313 print_get_opcode ();