1 /* This file is part of the program psim.
3 Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
40 /****************************************************************/
46 static int hi_bit_nr = 0;
47 static int insn_size = max_insn_size;
48 static int idecode_expand_semantics = 0;
49 static int idecode_cache = 0;
50 static int number_lines = 1;
53 /****************************************************************/
56 static char *cache_idecode_formal =
58 instruction_word instruction,\n\
60 idecode_cache *cache_entry";
62 static char *cache_idecode_actual = "processor, instruction, cia, cache_entry";
64 static char *cache_semantic_formal =
66 idecode_cache *cache_entry,\n\
69 static char *semantic_formal =
71 instruction_word instruction,\n\
74 static char *semantic_actual = "processor, instruction, cia";
78 /****************************************************************/
81 typedef struct _filter filter;
86 static filter *filters = NULL;
89 /****************************************************************/
92 typedef struct _cache_rules cache_rules;
101 static cache_rules *cache_table;
110 nr_cache_rule_fields,
114 load_cache_rules(char *file_name)
116 table *file = table_open(file_name, nr_cache_rule_fields, 0);
118 cache_rules *table = NULL;
119 cache_rules **curr_rule = &table;
120 while ((entry = table_entry_read(file)) != NULL) {
121 cache_rules *new_rule = ZALLOC(cache_rules);
122 new_rule->valid = target_a2i(hi_bit_nr, entry->fields[ca_valid]);
123 new_rule->old_name = entry->fields[ca_old_name];
124 new_rule->new_name = entry->fields[ca_new_name];
125 new_rule->type = (strlen(entry->fields[ca_type])
126 ? entry->fields[ca_type]
128 new_rule->expression = (strlen(entry->fields[ca_expression]) > 0
129 ? entry->fields[ca_expression]
131 *curr_rule = new_rule;
132 curr_rule = &new_rule->next;
140 dump_cache_rule(cache_rules* rule,
143 dumpf(indent, "((cache_rules*)0x%x\n", rule);
144 dumpf(indent, " (valid %d)\n", rule->valid);
145 dumpf(indent, " (old_name \"%s\")\n", rule->old_name);
146 dumpf(indent, " (new_name \"%s\")\n", rule->new_name);
147 dumpf(indent, " (type \"%s\")\n", rule->type);
148 dumpf(indent, " (expression \"%s\")\n", rule->expression);
149 dumpf(indent, " (next 0x%x)\n", rule->next);
150 dumpf(indent, " )\n");
155 dump_cache_rules(cache_rules* rule, int indent)
158 dump_cache_rule(rule, indent);
164 /****************************************************************/
167 typedef struct _opcode_rules opcode_rules;
168 struct _opcode_rules {
174 char *force_expansion;
176 unsigned special_mask;
177 unsigned special_value;
178 unsigned special_rule;
181 static opcode_rules *opcode_table;
199 static opcode_rules *
200 load_opcode_rules(char *file_name)
202 table *file = table_open(file_name, nr_opcode_fields, 0);
204 opcode_rules *table = NULL;
205 opcode_rules **curr_rule = &table;
206 while ((entry = table_entry_read(file)) != NULL) {
207 opcode_rules *new_rule = ZALLOC(opcode_rules);
208 new_rule->first = target_a2i(hi_bit_nr, entry->fields[op_first]);
209 new_rule->last = target_a2i(hi_bit_nr, entry->fields[op_last]);
210 new_rule->force_first = target_a2i(hi_bit_nr, entry->fields[op_force_first]);
211 new_rule->force_last = target_a2i(hi_bit_nr, entry->fields[op_force_last]);
212 new_rule->force_slash = a2i(entry->fields[op_force_slash]);
213 new_rule->force_expansion = entry->fields[op_force_expansion];
214 new_rule->use_switch = a2i(entry->fields[op_use_switch]);
215 new_rule->special_mask = a2i(entry->fields[op_special_mask]);
216 new_rule->special_value = a2i(entry->fields[op_special_value]);
217 new_rule->special_rule = a2i(entry->fields[op_special_rule]);
218 *curr_rule = new_rule;
219 curr_rule = &new_rule->next;
226 dump_opcode_rule(opcode_rules *rule,
229 dumpf(indent, "((opcode_rules*)%p\n", rule);
231 dumpf(indent, " (first %d)\n", rule->first);
232 dumpf(indent, " (last %d)\n", rule->last);
233 dumpf(indent, " (force_first %d)\n", rule->force_first);
234 dumpf(indent, " (force_last %d)\n", rule->force_last);
235 dumpf(indent, " (force_slash %d)\n", rule->force_slash);
236 dumpf(indent, " (force_expansion \"%s\")\n", rule->force_expansion);
237 dumpf(indent, " (use_switch %d)\n", rule->use_switch);
238 dumpf(indent, " (special_mask 0x%x)\n", rule->special_mask);
239 dumpf(indent, " (special_value 0x%x)\n", rule->special_value);
240 dumpf(indent, " (special_rule 0x%x)\n", rule->special_rule);
241 dumpf(indent, " (next 0x%x)\n", rule->next);
243 dumpf(indent, " )\n");
248 dump_opcode_rules(opcode_rules *rule,
252 dump_opcode_rule(rule, indent);
258 /****************************************************************/
260 typedef struct _insn_field insn_field;
275 typedef struct _insn_fields insn_fields;
276 struct _insn_fields {
277 insn_field *bits[max_insn_size];
284 parse_insn_format(table_entry *entry,
288 insn_fields *fields = ZALLOC(insn_fields);
290 /* create a leading sentinal */
291 fields->first = ZALLOC(insn_field);
292 fields->first->first = -1;
293 fields->first->last = -1;
294 fields->first->width = 0;
296 /* and a trailing sentinal */
297 fields->last = ZALLOC(insn_field);
298 fields->last->first = insn_size;
299 fields->last->last = insn_size;
300 fields->last->width = 0;
302 /* link them together */
303 fields->first->next = fields->last;
304 fields->last->prev = fields->first;
306 /* now work through the formats */
309 while (*chp != '\0') {
314 insn_field *new_field;
317 if (!isdigit(*chp)) {
318 error("%s:%d: missing position field at `%s'\n",
319 entry->file_name, entry->line_nr, chp);
322 /* break out the bit position */
324 while (isdigit(*chp))
326 strlen_pos = chp - start_pos;
327 if (*chp == '.' && strlen_pos > 0)
330 error("%s:%d: missing field value at %s\n",
331 entry->file_name, entry->line_nr, chp);
335 /* break out the value */
337 while ((*start_val == '/' && *chp == '/')
338 || (isdigit(*start_val) && isdigit(*chp))
339 || (isalpha(*start_val) && (isalnum(*chp) || *chp == '_')))
341 strlen_val = chp - start_val;
344 else if (*chp != '\0' || strlen_val == 0) {
345 error("%s:%d: missing field terminator at %s\n",
346 entry->file_name, entry->line_nr, chp);
350 /* create a new field and insert it */
351 new_field = ZALLOC(insn_field);
352 new_field->next = fields->last;
353 new_field->prev = fields->last->prev;
354 new_field->next->prev = new_field;
355 new_field->prev->next = new_field;
358 new_field->val_string = (char*)zalloc(strlen_val+1);
359 strncpy(new_field->val_string, start_val, strlen_val);
360 if (isdigit(*new_field->val_string)) {
361 new_field->val_int = a2i(new_field->val_string);
362 new_field->is_int = 1;
364 else if (new_field->val_string[0] == '/') {
365 new_field->is_slash = 1;
368 new_field->is_string = 1;
372 new_field->pos_string = (char*)zalloc(strlen_pos+1);
373 strncpy(new_field->pos_string, start_pos, strlen_pos);
374 new_field->first = target_a2i(hi_bit_nr, new_field->pos_string);
375 new_field->last = new_field->next->first - 1; /* guess */
376 new_field->width = new_field->last - new_field->first + 1; /* guess */
377 new_field->prev->last = new_field->first-1; /*fix*/
378 new_field->prev->width = new_field->first - new_field->prev->first; /*fix*/
381 /* fiddle first/last so that the sentinals `disapear' */
382 ASSERT(fields->first->last < 0);
383 ASSERT(fields->last->first >= insn_size);
384 fields->first = fields->first->next;
385 fields->last = fields->last->prev;
387 /* now go over this again, pointing each bit position at a field
392 field = fields->first;
393 for (i = 0; i < insn_size; i++) {
394 while (field->last < i)
396 fields->bits[i] = field;
400 /* go over each of the fields, and compute a `value' for the insn */
404 for (field = fields->first;
405 field->last < insn_size;
406 field = field->next) {
407 fields->value <<= field->width;
409 fields->value |= field->val_int;
417 field_constant_int = 1,
418 field_constant_slash = 2,
419 field_constant_string = 3
420 } constant_field_types;
424 insn_field_is_constant(insn_field *field,
427 /* field is an integer */
429 return field_constant_int;
430 /* field is `/' and treating that as a constant */
431 if (field->is_slash && rule->force_slash)
432 return field_constant_slash;
433 /* field, though variable is on the list */
434 if (field->is_string && rule->force_expansion != NULL) {
435 char *forced_fields = rule->force_expansion;
436 while (*forced_fields != '\0') {
438 char *end = strchr(forced_fields, ',');
440 field_len = strlen(forced_fields);
442 field_len = end-forced_fields;
443 if (strncmp(forced_fields, field->val_string, field_len) == 0
444 && field->val_string[field_len] == '\0')
445 return field_constant_string;
446 forced_fields += field_len;
447 if (*forced_fields == ',')
456 dump_insn_field(insn_field *field,
460 printf("(insn_field*)0x%x\n", (unsigned)field);
462 dumpf(indent, "(first %d)\n", field->first);
464 dumpf(indent, "(last %d)\n", field->last);
466 dumpf(indent, "(width %d)\n", field->width);
469 dumpf(indent, "(is_int %d)\n", field->val_int);
472 dumpf(indent, "(is_slash)\n");
474 if (field->is_string)
475 dumpf(indent, "(is_string `%s')\n", field->val_string);
477 dumpf(indent, "(next 0x%x)\n", field->next);
479 dumpf(indent, "(prev 0x%x)\n", field->prev);
485 dump_insn_fields(insn_fields *fields,
490 printf("(insn_fields*)%p\n", fields);
492 dumpf(indent, "(first 0x%x)\n", fields->first);
493 dumpf(indent, "(last 0x%x)\n", fields->last);
495 dumpf(indent, "(value 0x%x)\n", fields->value);
497 for (i = 0; i < insn_size; i++) {
498 dumpf(indent, "(bits[%d] ", i, fields->bits[i]);
499 dump_insn_field(fields->bits[i], indent+1);
500 dumpf(indent, " )\n");
506 /****************************************************************/
508 typedef struct _opcode_field opcode_field;
509 struct _opcode_field {
513 opcode_field *parent;
517 dump_opcode_field(opcode_field *field, int indent, int levels)
519 printf("(opcode_field*)%p\n", field);
520 if (levels && field != NULL) {
521 dumpf(indent, "(first %d)\n", field->first);
522 dumpf(indent, "(last %d)\n", field->last);
523 dumpf(indent, "(is_boolean %d)\n", field->is_boolean);
524 dumpf(indent, "(parent ");
525 dump_opcode_field(field->parent, indent, levels-1);
530 /****************************************************************/
532 typedef struct _insn_bits insn_bits;
537 opcode_field *opcode;
543 dump_insn_bits(insn_bits *bits, int indent, int levels)
545 printf("(insn_bits*)%p\n", bits);
547 if (levels && bits != NULL) {
548 dumpf(indent, "(value %d)\n", bits->value);
549 dumpf(indent, "(opcode ");
550 dump_opcode_field(bits->opcode, indent+1, 0);
551 dumpf(indent, " )\n");
552 dumpf(indent, "(field ");
553 dump_insn_field(bits->field, indent+1);
554 dumpf(indent, " )\n");
555 dumpf(indent, "(last ");
556 dump_insn_bits(bits->last, indent+1, levels-1);
561 /****************************************************************/
575 function_type = insn_format,
576 function_name = insn_name,
577 function_param = insn_comment
578 } function_table_fields;
581 model_name = insn_mnemonic,
582 model_identifer = insn_name,
583 model_default = insn_comment,
584 } model_table_fields;
586 typedef struct _insn insn;
588 table_entry *file_entry;
593 typedef struct _model model;
597 char *printable_name;
599 table_model_entry *func_unit_start;
600 table_model_entry *func_unit_end;
603 typedef struct _insn_table insn_table;
606 insn_bits *expanded_bits;
611 opcode_rules *opcode_rule;
612 opcode_field *opcode;
622 nr_insn_model_table_fields
623 } insn_model_table_fields;
625 static model *models;
626 static model *last_model;
628 static insn *model_macros;
629 static insn *last_model_macro;
631 static insn *model_functions;
632 static insn *last_model_function;
634 static insn *model_internal;
635 static insn *last_model_internal;
637 static insn *model_static;
638 static insn *last_model_static;
640 static insn *model_data;
641 static insn *last_model_data;
643 static int max_model_fields_len;
646 insn_table_insert_function(insn_table *table,
647 table_entry *file_entry)
649 /* create a new function */
650 insn *new_function = ZALLOC(insn);
651 new_function->file_entry = file_entry;
653 /* append it to the end of the function list */
654 if (table->last_function)
655 table->last_function->next = new_function;
657 table->functions = new_function;
658 table->last_function = new_function;
662 insn_table_insert_insn(insn_table *table,
663 table_entry *file_entry,
666 insn **ptr_to_cur_insn = &table->insns;
667 insn *cur_insn = *ptr_to_cur_insn;
668 table_model_entry *insn_model_ptr;
671 /* create a new instruction */
672 insn *new_insn = ZALLOC(insn);
673 new_insn->file_entry = file_entry;
674 new_insn->fields = fields;
676 /* Check out any model information returned to make sure the model
678 for(insn_model_ptr = file_entry->model_first; insn_model_ptr; insn_model_ptr = insn_model_ptr->next) {
679 char *name = insn_model_ptr->fields[insn_model_name];
680 int len = strlen (insn_model_ptr->fields[insn_model_fields]);
682 while (len > 0 && isspace(*insn_model_ptr->fields[insn_model_fields])) {
684 insn_model_ptr->fields[insn_model_fields]++;
687 if (max_model_fields_len < len)
688 max_model_fields_len = len;
690 for(model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
691 if (strcmp(name, model_ptr->printable_name) == 0) {
693 /* Replace the name field with that of the global model, so that when we
694 want to print it out, we can just compare pointers. */
695 insn_model_ptr->fields[insn_model_name] = model_ptr->printable_name;
701 error("%s:%d: machine model `%s' was not known about\n",
702 file_entry->file_name, file_entry->line_nr, name);
705 /* insert it according to the order of the fields */
706 while (cur_insn != NULL
707 && new_insn->fields->value >= cur_insn->fields->value) {
708 ptr_to_cur_insn = &cur_insn->next;
709 cur_insn = *ptr_to_cur_insn;
712 new_insn->next = cur_insn;
713 *ptr_to_cur_insn = new_insn;
719 static opcode_field *
720 insn_table_find_opcode_field(insn *insns,
724 opcode_field *curr_opcode = ZALLOC(opcode_field);
728 curr_opcode->first = insn_size;
729 curr_opcode->last = -1;
730 for (entry = insns; entry != NULL; entry = entry->next) {
731 insn_fields *fields = entry->fields;
732 opcode_field new_opcode;
734 /* find a start point for the opcode field */
735 new_opcode.first = rule->first;
736 while (new_opcode.first <= rule->last
738 || insn_field_is_constant(fields->bits[new_opcode.first],
739 rule) != field_constant_string)
741 || !insn_field_is_constant(fields->bits[new_opcode.first],
743 new_opcode.first = fields->bits[new_opcode.first]->last + 1;
744 ASSERT(new_opcode.first > rule->last
746 && insn_field_is_constant(fields->bits[new_opcode.first],
747 rule) == field_constant_string)
749 && insn_field_is_constant(fields->bits[new_opcode.first],
752 /* find the end point for the opcode field */
753 new_opcode.last = rule->last;
754 while (new_opcode.last >= rule->first
756 || insn_field_is_constant(fields->bits[new_opcode.last],
757 rule) != field_constant_string)
759 || !insn_field_is_constant(fields->bits[new_opcode.last],
761 new_opcode.last = fields->bits[new_opcode.last]->first - 1;
762 ASSERT(new_opcode.last < rule->first
764 && insn_field_is_constant(fields->bits[new_opcode.last],
765 rule) == field_constant_string)
767 && insn_field_is_constant(fields->bits[new_opcode.last],
770 /* now see if our current opcode needs expanding */
771 if (new_opcode.first <= rule->last
772 && curr_opcode->first > new_opcode.first)
773 curr_opcode->first = new_opcode.first;
774 if (new_opcode.last >= rule->first
775 && curr_opcode->last < new_opcode.last)
776 curr_opcode->last = new_opcode.last;
780 /* was any thing interesting found? */
781 if (curr_opcode->first > rule->last) {
782 ASSERT(curr_opcode->last < rule->first);
785 ASSERT(curr_opcode->last >= rule->first);
786 ASSERT(curr_opcode->first <= rule->last);
788 /* if something was found, check it includes the forced field range */
790 && curr_opcode->first > rule->force_first) {
791 curr_opcode->first = rule->force_first;
794 && curr_opcode->last < rule->force_last) {
795 curr_opcode->last = rule->force_last;
797 /* handle special case elminating any need to do shift after mask */
799 && rule->force_last == insn_size-1) {
800 curr_opcode->last = insn_size-1;
803 /* handle any special cases */
804 switch (rule->special_rule) {
805 case 0: /* let the above apply */
807 case 1: /* expand a limited nr of bits, ignoring the rest */
808 curr_opcode->first = rule->force_first;
809 curr_opcode->last = rule->force_last;
811 case 2: /* boolean field */
812 curr_opcode->is_boolean = 1;
821 insn_table_insert_expanded(insn_table *table,
826 insn_table **ptr_to_cur_entry = &table->entries;
827 insn_table *cur_entry = *ptr_to_cur_entry;
829 /* find the new table for this entry */
830 while (cur_entry != NULL
831 && cur_entry->opcode_nr < new_opcode_nr) {
832 ptr_to_cur_entry = &cur_entry->sibling;
833 cur_entry = *ptr_to_cur_entry;
836 if (cur_entry == NULL || cur_entry->opcode_nr != new_opcode_nr) {
837 insn_table *new_entry = ZALLOC(insn_table);
838 new_entry->opcode_nr = new_opcode_nr;
839 new_entry->expanded_bits = new_bits;
840 new_entry->opcode_rule = table->opcode_rule->next;
841 new_entry->sibling = cur_entry;
842 new_entry->parent = table;
843 *ptr_to_cur_entry = new_entry;
844 cur_entry = new_entry;
847 /* ASSERT new_bits == cur_entry bits */
848 ASSERT(cur_entry != NULL && cur_entry->opcode_nr == new_opcode_nr);
849 insn_table_insert_insn(cur_entry,
850 old_insn->file_entry,
855 insn_table_expand_opcode(insn_table *table,
862 if (field_nr > table->opcode->last) {
863 insn_table_insert_expanded(table, instruction, opcode_nr, bits);
866 insn_field *field = instruction->fields->bits[field_nr];
867 if (field->is_int || field->is_slash) {
868 ASSERT(field->first >= table->opcode->first
869 && field->last <= table->opcode->last);
870 insn_table_expand_opcode(table, instruction, field->last+1,
871 ((opcode_nr << field->width) + field->val_int),
876 int last_pos = ((field->last < table->opcode->last)
877 ? field->last : table->opcode->last);
878 int first_pos = ((field->first > table->opcode->first)
879 ? field->first : table->opcode->first);
880 int width = last_pos - first_pos + 1;
881 int last_val = (table->opcode->is_boolean
883 for (val = 0; val < last_val; val++) {
884 insn_bits *new_bits = ZALLOC(insn_bits);
885 new_bits->field = field;
886 new_bits->value = val;
887 new_bits->last = bits;
888 new_bits->opcode = table->opcode;
889 insn_table_expand_opcode(table, instruction, last_pos+1,
890 ((opcode_nr << width) | val),
898 insn_table_insert_expanding(insn_table *table,
901 insn_table_expand_opcode(table,
903 table->opcode->first,
905 table->expanded_bits);
910 insn_table_expand_insns(insn_table *table)
913 ASSERT(table->nr_insn >= 1);
915 /* determine a valid opcode */
916 while (table->opcode_rule) {
917 /* specials only for single instructions */
918 if ((table->nr_insn > 1
919 && table->opcode_rule->special_mask == 0
920 && table->opcode_rule->special_rule == 0)
921 || (table->nr_insn == 1
922 && table->opcode_rule->special_mask != 0
923 && ((table->insns->fields->value
924 & table->opcode_rule->special_mask)
925 == table->opcode_rule->special_value))
926 || (idecode_expand_semantics
927 && table->opcode_rule->special_mask == 0
928 && table->opcode_rule->special_rule == 0))
930 insn_table_find_opcode_field(table->insns,
932 table->nr_insn == 1/*string*/
934 if (table->opcode != NULL)
936 table->opcode_rule = table->opcode_rule->next;
939 /* did we find anything */
940 if (table->opcode == NULL) {
943 ASSERT(table->opcode != NULL);
945 /* back link what we found to its parent */
946 if (table->parent != NULL) {
947 ASSERT(table->parent->opcode != NULL);
948 table->opcode->parent = table->parent->opcode;
951 /* expand the raw instructions according to the opcode */
954 for (entry = table->insns; entry != NULL; entry = entry->next) {
955 insn_table_insert_expanding(table, entry);
959 /* and do the same for the sub entries */
962 for (entry = table->entries; entry != NULL; entry = entry->sibling) {
963 insn_table_expand_insns(entry);
970 model_table_insert(insn_table *table,
971 table_entry *file_entry)
975 /* create a new model */
976 model *new_model = ZALLOC(model);
978 new_model->name = file_entry->fields[model_identifer];
979 new_model->printable_name = file_entry->fields[model_name];
980 new_model->insn_default = file_entry->fields[model_default];
982 while (*new_model->insn_default && isspace(*new_model->insn_default))
983 new_model->insn_default++;
985 len = strlen(new_model->insn_default);
986 if (max_model_fields_len < len)
987 max_model_fields_len = len;
989 /* append it to the end of the model list */
991 last_model->next = new_model;
994 last_model = new_model;
998 model_table_insert_specific(insn_table *table,
999 table_entry *file_entry,
1003 insn *ptr = ZALLOC(insn);
1004 ptr->file_entry = file_entry;
1006 (*end_ptr)->next = ptr;
1015 insn_table_load_insns(char *file_name)
1017 table *file = table_open(file_name, nr_insn_table_fields, nr_insn_model_table_fields);
1018 insn_table *table = ZALLOC(insn_table);
1019 table_entry *file_entry;
1020 table->opcode_rule = opcode_table;
1022 while ((file_entry = table_entry_read(file)) != NULL) {
1023 if (it_is("function", file_entry->fields[insn_flags])
1024 || it_is("internal", file_entry->fields[insn_flags])) {
1025 insn_table_insert_function(table, file_entry);
1027 else if (it_is("model", file_entry->fields[insn_flags])) {
1028 model_table_insert(table, file_entry);
1030 else if (it_is("model-macro", file_entry->fields[insn_flags])) {
1031 model_table_insert_specific(table, file_entry, &model_macros, &last_model_macro);
1033 else if (it_is("model-function", file_entry->fields[insn_flags])) {
1034 model_table_insert_specific(table, file_entry, &model_functions, &last_model_function);
1036 else if (it_is("model-internal", file_entry->fields[insn_flags])) {
1037 model_table_insert_specific(table, file_entry, &model_internal, &last_model_internal);
1039 else if (it_is("model-static", file_entry->fields[insn_flags])) {
1040 model_table_insert_specific(table, file_entry, &model_static, &last_model_static);
1042 else if (it_is("model-data", file_entry->fields[insn_flags])) {
1043 model_table_insert_specific(table, file_entry, &model_data, &last_model_data);
1046 insn_fields *fields;
1047 /* skip instructions that aren't relevant to the mode */
1048 filter *filt = filters;
1049 while (filt != NULL) {
1050 if (it_is(filt->flag, file_entry->fields[insn_flags]))
1055 /* create/insert the new instruction */
1056 fields = parse_insn_format(file_entry,
1057 file_entry->fields[insn_format]);
1058 insn_table_insert_insn(table, file_entry, fields);
1067 dump_insn(insn *entry, int indent, int levels)
1069 printf("(insn*)%p\n", entry);
1071 if (levels && entry != NULL) {
1073 dumpf(indent, "(file_entry ");
1074 dump_table_entry(entry->file_entry, indent+1);
1075 dumpf(indent, " )\n");
1077 dumpf(indent, "(fields ");
1078 dump_insn_fields(entry->fields, indent+1);
1079 dumpf(indent, " )\n");
1081 dumpf(indent, "(next ");
1082 dump_insn(entry->next, indent+1, levels-1);
1083 dumpf(indent, " )\n");
1091 dump_insn_table(insn_table *table,
1092 int indent, int levels)
1095 printf("(insn_table*)%p\n", table);
1097 if (levels && table != NULL) {
1099 dumpf(indent, "(opcode_nr %d)\n", table->opcode_nr);
1101 dumpf(indent, "(expanded_bits ");
1102 dump_insn_bits(table->expanded_bits, indent+1, -1);
1103 dumpf(indent, " )\n");
1105 dumpf(indent, "(int nr_insn %d)\n", table->nr_insn);
1107 dumpf(indent, "(insns ");
1108 dump_insn(table->insns, indent+1, table->nr_insn);
1109 dumpf(indent, " )\n");
1111 dumpf(indent, "(opcode_rule ");
1112 dump_opcode_rule(table->opcode_rule, indent+1);
1113 dumpf(indent, " )\n");
1115 dumpf(indent, "(opcode ");
1116 dump_opcode_field(table->opcode, indent+1, 1);
1117 dumpf(indent, " )\n");
1119 dumpf(indent, "(nr_entries %d)\n", table->entries);
1120 dumpf(indent, "(entries ");
1121 dump_insn_table(table->entries, indent+1, table->nr_entries);
1122 dumpf(indent, " )\n");
1124 dumpf(indent, "(sibling ", table->sibling);
1125 dump_insn_table(table->sibling, indent+1, levels-1);
1126 dumpf(indent, " )\n");
1128 dumpf(indent, "(parent ", table->parent);
1129 dump_insn_table(table->parent, indent+1, 0);
1130 dumpf(indent, " )\n");
1136 /****************************************************************/
1140 lf_print_insn_bits(lf *file, insn_bits *bits)
1144 lf_print_insn_bits(file, bits->last);
1145 lf_putchr(file, '_');
1146 lf_putstr(file, bits->field->val_string);
1147 if (!bits->opcode->is_boolean || bits->value == 0) {
1148 if (bits->opcode->last < bits->field->last)
1149 lf_putint(file, bits->value << (bits->field->last - bits->opcode->last));
1151 lf_putint(file, bits->value);
1156 lf_print_opcodes(lf *file,
1159 if (table != NULL) {
1161 lf_printf(file, "_%d_%d",
1162 table->opcode->first,
1163 table->opcode->last);
1164 if (table->parent == NULL) break;
1165 lf_printf(file, "__%d", table->opcode_nr);
1166 table = table->parent;
1172 lf_print_table_name(lf *file,
1175 lf_printf(file, "idecode_table");
1176 lf_print_opcodes(file, table);
1182 function_name_prefix_semantics,
1183 function_name_prefix_idecode,
1184 function_name_prefix_itable,
1185 function_name_prefix_none
1186 } lf_function_name_prefixes;
1189 lf_print_function_name(lf *file,
1191 insn_bits *expanded_bits,
1192 lf_function_name_prefixes prefix)
1197 case function_name_prefix_semantics:
1198 lf_putstr(file, "semantic_");
1200 case function_name_prefix_idecode:
1201 lf_printf(file, "idecode_");
1203 case function_name_prefix_itable:
1204 lf_putstr(file, "itable_");
1210 /* the function name */
1213 for (pos = basename;
1221 lf_putchr(file, '_');
1224 lf_putchr(file, *pos);
1231 if (idecode_expand_semantics)
1232 lf_print_insn_bits(file, expanded_bits);
1237 lf_print_idecode_table(lf *file,
1240 int can_assume_leaf;
1241 opcode_rules *opcode_rule;
1243 /* have a look at the rule table, if all table rules follow all
1244 switch rules, I can assume that all end points are leaves */
1245 opcode_rule = opcode_table;
1246 while (opcode_rule != NULL
1247 && opcode_rule->use_switch)
1248 opcode_rule = opcode_rule->next;
1249 while (opcode_rule != NULL
1250 && opcode_rule->use_switch
1251 && opcode_rule->special_rule)
1252 opcode_rule = opcode_rule->next;
1253 can_assume_leaf = opcode_rule == NULL;
1255 lf_printf(file, "{\n");
1256 lf_indent(file, +2);
1258 lf_printf(file, "idecode_table_entry *table = ");
1259 lf_print_table_name(file, entry);
1260 lf_printf(file, ";\n");
1261 lf_printf(file, "int opcode = EXTRACTED32(instruction, %d, %d);\n",
1262 i2target(hi_bit_nr, entry->opcode->first),
1263 i2target(hi_bit_nr, entry->opcode->last));
1264 lf_printf(file, "idecode_table_entry *table_entry = table + opcode;\n");
1265 lf_printf(file, "while (1) {\n");
1266 lf_indent(file, +2);
1268 lf_printf(file, "/* nonzero mask -> another table */\n");
1269 lf_printf(file, "while (table_entry->mask != 0) {\n");
1270 lf_indent(file, +2);
1272 lf_printf(file, "table = ((idecode_table_entry*)\n");
1273 lf_printf(file, " table_entry->function_or_table);\n");
1274 lf_printf(file, "opcode = ((instruction & table_entry->mask)\n");
1275 lf_printf(file, " >> table_entry->shift);\n");
1276 lf_printf(file, "table_entry = table + opcode;\n");
1278 lf_indent(file, -2);
1279 lf_printf(file, "}\n");
1280 lf_printf(file, "ASSERT(table_entry->mask == 0);\n");
1281 if (can_assume_leaf)
1282 lf_printf(file, "ASSERT(table_entry->shift == 0);\n");
1284 lf_printf(file, "if (table_entry->shift == 0)\n");
1285 lf_indent(file, +2);
1287 if (idecode_cache) {
1288 lf_printf(file, "return (((idecode_crack*)\n");
1289 lf_printf(file, " table_entry->function_or_table)\n");
1290 lf_printf(file, " (%s));\n", cache_idecode_actual);
1293 lf_printf(file, "return (((idecode_semantic*)\n");
1294 lf_printf(file, " table_entry->function_or_table)\n");
1295 lf_printf(file, " (%s));\n", semantic_actual);
1297 if (!can_assume_leaf) {
1298 lf_indent(file, -2);
1299 lf_printf(file, "/* must be a boolean */\n");
1300 lf_printf(file, "opcode = (instruction & table_entry->shift) != 0;\n");
1301 lf_printf(file, "table = ((idecode_table_entry*)\n");
1302 lf_printf(file, " table_entry->function_or_table);\n");
1303 lf_printf(file, "table_entry = table + opcode;\n");
1306 lf_indent(file, -2);
1307 lf_printf(file, "}\n");
1309 lf_indent(file, -2);
1310 lf_printf(file, "}\n");
1315 lf_print_my_prefix(lf *file,
1316 table_entry *file_entry,
1319 lf_printf(file, "const char *const my_prefix __attribute__((__unused__)) = \n");
1320 lf_printf(file, " \"%s:%s:%s:%d\";\n",
1321 filter_filename (file_entry->file_name),
1322 (idecode ? "idecode" : "semantics"),
1323 file_entry->fields[insn_name],
1324 file_entry->line_nr);
1325 lf_printf(file, "const itable_index my_index __attribute__((__unused__)) = ");
1326 lf_print_function_name(file,
1327 file_entry->fields[insn_name],
1329 function_name_prefix_itable);
1330 lf_printf(file, ";\n");
1335 lf_print_ptrace(lf *file,
1338 lf_printf(file, "\n");
1339 lf_printf(file, "ITRACE(trace_%s, (\"\\n\"));\n",
1340 (idecode ? "idecode" : "semantics"));
1344 /****************************************************************/
1346 typedef void leaf_handler
1350 typedef void padding_handler
1358 insn_table_traverse_tree(insn_table *table,
1361 leaf_handler *start,
1364 padding_handler *padding)
1369 ASSERT(table != NULL
1370 && table->opcode != NULL
1371 && table->nr_entries > 0
1372 && table->entries != 0);
1374 if (start != NULL && depth >= 0)
1375 start(table, data, depth);
1377 for (entry_nr = 0, entry = table->entries;
1378 entry_nr < (table->opcode->is_boolean
1380 : (1 << (table->opcode->last - table->opcode->first + 1)));
1383 || (!table->opcode->is_boolean
1384 && entry_nr < entry->opcode_nr)) {
1385 if (padding != NULL && depth >= 0)
1386 padding(table, data, depth, entry_nr);
1389 ASSERT(entry != NULL && (entry->opcode_nr == entry_nr
1390 || table->opcode->is_boolean));
1391 if (entry->opcode != NULL && depth != 0) {
1392 insn_table_traverse_tree(entry, data, depth+1,
1393 start, leaf, end, padding);
1395 else if (depth >= 0) {
1397 leaf(entry, data, depth);
1399 entry = entry->sibling;
1402 if (end != NULL && depth >= 0)
1403 end(table, data, depth);
1407 typedef void function_handler
1410 table_entry *function);
1413 insn_table_traverse_function(insn_table *table,
1415 function_handler *leaf)
1418 for (function = table->functions;
1420 function = function->next) {
1421 leaf(table, data, function->file_entry);
1426 typedef void insn_handler
1432 insn_table_traverse_insn(insn_table *table,
1437 for (instruction = table->insns;
1438 instruction != NULL;
1439 instruction = instruction->next) {
1440 leaf(table, data, instruction);
1446 update_depth(insn_table *entry,
1450 int *max_depth = (int*)data;
1451 if (*max_depth < depth)
1457 insn_table_depth(insn_table *table)
1460 insn_table_traverse_tree(table,
1471 /****************************************************************/
1474 dump_traverse_start(insn_table *table,
1478 dumpf(depth*2, "(%d\n", table->opcode_nr);
1482 dump_traverse_leaf(insn_table *entry,
1486 ASSERT(entry->nr_entries == 0
1487 && entry->nr_insn == 1
1488 && entry->opcode == NULL);
1489 dumpf(depth*2, ".%d %s\n", entry->opcode_nr,
1490 entry->insns->file_entry->fields[insn_format]);
1494 dump_traverse_end(insn_table *table,
1498 dumpf(depth*2, ")\n");
1502 dump_traverse_padding(insn_table *table,
1507 dumpf(depth*2, ".<%d>\n", opcode_nr);
1512 dump_traverse(insn_table *table)
1514 insn_table_traverse_tree(table, NULL, 1,
1515 dump_traverse_start,
1518 dump_traverse_padding);
1522 /****************************************************************/
1526 lf_print_semantic_function_header(lf *file,
1528 insn_bits *expanded_bits,
1529 int is_function_definition,
1530 int is_inline_function)
1532 lf_printf(file, "\n");
1533 lf_printf(file, "STATIC_SEMANTICS unsigned_word ");
1534 lf_print_function_name(file,
1537 function_name_prefix_semantics);
1538 lf_printf(file, "\n(%s)",
1539 (idecode_cache ? cache_semantic_formal : semantic_formal));
1540 if (!is_function_definition)
1541 lf_printf(file, ";");
1542 lf_printf(file, "\n");
1547 semantics_h_leaf(insn_table *entry,
1551 lf *file = (lf*)data;
1552 ASSERT(entry->nr_insn == 1);
1553 lf_print_semantic_function_header(file,
1554 entry->insns->file_entry->fields[insn_name],
1555 entry->expanded_bits,
1556 0/* isnt function definition*/,
1557 !idecode_cache && entry->parent->opcode_rule->use_switch);
1561 semantics_h_insn(insn_table *entry,
1565 lf *file = (lf*)data;
1566 lf_print_semantic_function_header(file,
1567 instruction->file_entry->fields[insn_name],
1569 0/*isnt function definition*/,
1570 0/*isnt inline function*/);
1574 semantics_h_function(insn_table *entry,
1576 table_entry *function)
1578 lf *file = (lf*)data;
1579 if (function->fields[function_type] == NULL
1580 || function->fields[function_type][0] == '\0') {
1581 lf_print_semantic_function_header(file,
1582 function->fields[function_name],
1584 0/*isnt function definition*/,
1585 1/*is inline function*/);
1588 lf_printf(file, "\n");
1589 lf_printf(file, "INLINE_SEMANTICS %s %s\n(%s);\n",
1590 function->fields[function_type],
1591 function->fields[function_name],
1592 function->fields[function_param]);
1598 gen_semantics_h(insn_table *table, lf *file)
1601 lf_print_copyleft(file);
1602 lf_printf(file, "\n");
1603 lf_printf(file, "#ifndef _SEMANTICS_H_\n");
1604 lf_printf(file, "#define _SEMANTICS_H_\n");
1605 lf_printf(file, "\n");
1606 lf_printf(file, "#ifndef INLINE_SEMANTICS\n");
1607 lf_printf(file, "#define INLINE_SEMANTICS\n");
1608 lf_printf(file, "#endif\n");
1609 lf_printf(file, "\n");
1610 lf_printf(file, "#ifndef STATIC_SEMANTICS\n");
1611 lf_printf(file, "#define STATIC_SEMANTICS\n");
1612 lf_printf(file, "#endif\n");
1613 lf_printf(file, "\n");
1614 lf_printf(file, "\n");
1616 /* output a declaration for all functions */
1617 insn_table_traverse_function(table,
1619 semantics_h_function);
1621 /* output a declaration for all instructions */
1622 if (idecode_expand_semantics)
1623 insn_table_traverse_tree(table,
1627 semantics_h_leaf, /* leaf */
1629 NULL); /* padding */
1631 insn_table_traverse_insn(table,
1635 lf_printf(file, "\n");
1636 lf_printf(file, "#endif /* _SEMANTICS_H_ */\n");
1640 /****************************************************************/
1642 typedef struct _icache_tree icache_tree;
1643 struct _icache_tree {
1646 icache_tree *children;
1649 static icache_tree *
1650 icache_tree_insert(icache_tree *tree,
1653 icache_tree *new_tree;
1655 icache_tree **ptr_to_cur_tree = &tree->children;
1656 icache_tree *cur_tree = *ptr_to_cur_tree;
1657 while (cur_tree != NULL
1658 && strcmp(cur_tree->name, name) < 0) {
1659 ptr_to_cur_tree = &cur_tree->next;
1660 cur_tree = *ptr_to_cur_tree;
1662 ASSERT(cur_tree == NULL
1663 || strcmp(cur_tree->name, name) >= 0);
1664 /* already in the tree */
1665 if (cur_tree != NULL
1666 && strcmp(cur_tree->name, name) == 0)
1668 /* missing, insert it */
1669 ASSERT(cur_tree == NULL
1670 || strcmp(cur_tree->name, name) > 0);
1671 new_tree = ZALLOC(icache_tree);
1672 new_tree->name = name;
1673 new_tree->next = cur_tree;
1674 *ptr_to_cur_tree = new_tree;
1679 static icache_tree *
1680 insn_table_cache_fields(insn_table *table)
1682 icache_tree *tree = ZALLOC(icache_tree);
1684 for (instruction = table->insns;
1685 instruction != NULL;
1686 instruction = instruction->next) {
1689 icache_tree_insert(tree,
1690 instruction->file_entry->fields[insn_form]);
1691 for (field = instruction->fields->first;
1693 field = field->next) {
1694 if (field->is_string)
1695 icache_tree_insert(form, field->val_string);
1704 gen_icache_h(icache_tree *tree,
1707 lf_print_copyleft(file);
1708 lf_printf(file, "\n");
1709 lf_printf(file, "#ifndef _ICACHE_H_\n");
1710 lf_printf(file, "#define _ICACHE_H_\n");
1711 lf_printf(file, "\n");
1712 lf_printf(file, "#ifndef INLINE_ICACHE\n");
1713 lf_printf(file, "#define INLINE_ICACHE\n");
1714 lf_printf(file, "#endif\n");
1715 lf_printf(file, "\n");
1717 lf_printf(file, "#define WITH_IDECODE_CACHE_SIZE %d\n",
1719 lf_printf(file, "\n");
1721 /* create an instruction cache if being used */
1722 if (idecode_cache) {
1724 lf_printf(file, "typedef struct _idecode_cache {\n");
1725 lf_printf(file, " unsigned_word address;\n");
1726 lf_printf(file, " void *semantic;\n");
1727 lf_printf(file, " union {\n");
1728 for (form = tree->children;
1730 form = form->next) {
1732 lf_printf(file, " struct {\n");
1733 for (field = form->children;
1735 field = field->next) {
1736 cache_rules *cache_rule;
1738 for (cache_rule = cache_table;
1740 cache_rule = cache_rule->next) {
1741 if (strcmp(field->name, cache_rule->old_name) == 0) {
1743 if (cache_rule->new_name != NULL)
1744 lf_printf(file, " %s %s; /* %s */\n",
1745 (cache_rule->type == NULL
1747 : cache_rule->type),
1748 cache_rule->new_name,
1749 cache_rule->old_name);
1753 lf_printf(file, " unsigned %s;\n", field->name);
1755 lf_printf(file, " } %s;\n", form->name);
1757 lf_printf(file, " } crack;\n");
1758 lf_printf(file, "} idecode_cache;\n");
1761 /* alernativly, since no cache, #define the fields to be
1762 extractions from the instruction variable. Emit a dummy
1763 definition for idecode_cache to allow model_issue to not
1764 be #ifdefed at the call level */
1765 cache_rules *cache_rule;
1766 lf_printf(file, "\n");
1767 lf_printf(file, "typedef void idecode_cache;\n");
1768 lf_printf(file, "\n");
1769 for (cache_rule = cache_table;
1771 cache_rule = cache_rule->next) {
1772 if (cache_rule->expression != NULL
1773 && strlen(cache_rule->expression) > 0)
1774 lf_printf(file, "#define %s %s\n",
1775 cache_rule->new_name, cache_rule->expression);
1779 lf_printf(file, "\n");
1780 lf_printf(file, "#endif /* _ICACHE_H_ */\n");
1786 /****************************************************************/
1790 lf_print_c_extraction(lf *file,
1794 char *field_expression,
1795 insn_field *cur_field,
1797 int get_value_from_cache,
1798 int put_value_in_cache)
1800 ASSERT(field_name != NULL);
1802 && (!bits->opcode->is_boolean || bits->value == 0)
1803 && strcmp(field_name, cur_field->val_string) == 0) {
1804 ASSERT(bits->field == cur_field);
1805 ASSERT(field_type == NULL);
1806 table_entry_lf_c_line_nr(file, instruction->file_entry);
1807 lf_printf(file, "const unsigned %s __attribute__((__unused__)) = ",
1809 if (bits->opcode->last < bits->field->last)
1810 lf_printf(file, "%d;\n",
1811 bits->value << (bits->field->last - bits->opcode->last));
1813 lf_printf(file, "%d;\n", bits->value);
1816 /* put the field in the local variable */
1817 table_entry_lf_c_line_nr(file, instruction->file_entry);
1818 lf_printf(file, "%s const %s __attribute__((__unused__)) = ",
1819 field_type == NULL ? "unsigned" : field_type,
1821 /* getting it from the cache */
1822 if (get_value_from_cache || put_value_in_cache) {
1823 lf_printf(file, "cache_entry->crack.%s.%s",
1824 instruction->file_entry->fields[insn_form],
1826 if (put_value_in_cache) /* also put it in the cache? */
1827 lf_printf(file, " = ");
1829 if (!get_value_from_cache) {
1830 if (strcmp(field_name, cur_field->val_string) == 0)
1831 lf_printf(file, "EXTRACTED32(instruction, %d, %d)",
1832 i2target(hi_bit_nr, cur_field->first),
1833 i2target(hi_bit_nr, cur_field->last));
1834 else if (field_expression != NULL)
1835 lf_printf(file, "%s", field_expression);
1837 lf_printf(file, "eval_%s", field_name);
1839 lf_printf(file, ";\n");
1845 lf_print_c_extractions(lf *file,
1847 insn_bits *expanded_bits,
1848 int get_value_from_cache,
1849 int put_value_in_cache)
1851 insn_field *cur_field;
1853 /* extract instruction fields */
1854 lf_printf(file, "/* extraction: %s */\n",
1855 instruction->file_entry->fields[insn_format]);
1857 for (cur_field = instruction->fields->first;
1858 cur_field->first < insn_size;
1859 cur_field = cur_field->next) {
1860 if (cur_field->is_string) {
1863 /* find any corresponding value */
1864 for (bits = expanded_bits;
1866 bits = bits->last) {
1867 if (bits->field == cur_field)
1870 /* try the cache rule table for what to do */
1871 if (get_value_from_cache || put_value_in_cache) {
1872 cache_rules *cache_rule;
1873 for (cache_rule = cache_table;
1875 cache_rule = cache_rule->next) {
1876 if (strcmp(cur_field->val_string, cache_rule->old_name) == 0) {
1878 if (cache_rule->valid > 1 && put_value_in_cache)
1879 lf_print_c_extraction(file,
1881 cache_rule->new_name,
1883 cache_rule->expression,
1888 else if (cache_rule->valid == 1)
1889 lf_print_c_extraction(file,
1891 cache_rule->new_name,
1893 cache_rule->expression,
1896 get_value_from_cache,
1897 put_value_in_cache);
1901 if (found_rule == 0)
1902 lf_print_c_extraction(file,
1904 cur_field->val_string,
1909 get_value_from_cache,
1910 put_value_in_cache);
1911 /* if any (XXX == 0), output a corresponding test */
1912 if (instruction->file_entry->annex != NULL) {
1913 char *field_name = cur_field->val_string;
1914 char *is_0_ptr = instruction->file_entry->annex;
1915 int field_len = strlen(field_name);
1916 if (strlen(is_0_ptr) >= (strlen("_is_0") + field_len)) {
1917 is_0_ptr += field_len;
1918 while ((is_0_ptr = strstr(is_0_ptr, "_is_0")) != NULL) {
1919 if (strncmp(is_0_ptr - field_len, field_name, field_len) == 0
1920 && !isalpha(is_0_ptr[ - field_len - 1])) {
1921 table_entry_lf_c_line_nr(file, instruction->file_entry);
1922 lf_printf(file, "const unsigned %s_is_0 __attribute__((__unused__)) = (", field_name);
1924 lf_printf(file, "%d", bits->value);
1926 lf_printf(file, "%s", field_name);
1927 lf_printf(file, " == 0);\n");
1930 is_0_ptr += strlen("_is_0");
1934 /* any thing else ... */
1937 lf_print_lf_c_line_nr(file);
1942 lf_print_idecode_illegal(lf *file)
1945 lf_printf(file, "return idecode_illegal(%s);\n", cache_idecode_actual);
1947 lf_printf(file, "return semantic_illegal(%s);\n", semantic_actual);
1952 lf_print_idecode_floating_point_unavailable(lf *file)
1955 lf_printf(file, "return idecode_floating_point_unavailable(%s);\n",
1956 cache_idecode_actual);
1958 lf_printf(file, "return semantic_floating_point_unavailable(%s);\n",
1963 /* Output code to do any final checks on the decoded instruction.
1964 This includes things like verifying any on decoded fields have the
1965 correct value and checking that (for floating point) floating point
1966 hardware isn't disabled */
1969 lf_print_c_validate(lf *file,
1971 opcode_field *opcodes)
1973 /* Validate: unchecked instruction fields
1975 If any constant fields in the instruction were not checked by the
1976 idecode tables, output code to check that they have the correct
1979 unsigned check_mask = 0;
1980 unsigned check_val = 0;
1982 opcode_field *opcode;
1984 /* form check_mask/check_val containing what needs to be checked
1985 in the instruction */
1986 for (field = instruction->fields->first;
1987 field->first < insn_size;
1988 field = field->next) {
1990 check_mask <<= field->width;
1991 check_val <<= field->width;
1993 /* is it a constant that could need validating? */
1994 if (!field->is_int && !field->is_slash)
1997 /* has it been checked by a table? */
1998 for (opcode = opcodes; opcode != NULL; opcode = opcode->parent) {
1999 if (field->first >= opcode->first
2000 && field->last <= opcode->last)
2006 check_mask |= (1 << field->width)-1;
2007 check_val |= field->val_int;
2010 /* if any bits not checked by opcode tables, output code to check them */
2012 lf_printf(file, "\n");
2013 lf_printf(file, "/* validate: %s */\n",
2014 instruction->file_entry->fields[insn_format]);
2015 lf_printf(file, "if (WITH_RESERVED_BITS && (instruction & 0x%x) != 0x%x)\n",
2016 check_mask, check_val);
2017 lf_indent(file, +2);
2018 lf_print_idecode_illegal(file);
2019 lf_indent(file, -2);
2023 /* Validate floating point hardware
2025 If the simulator is being built with out floating point hardware
2026 (different to it being disabled in the MSR) then floating point
2027 instructions are invalid */
2029 if (it_is("f", instruction->file_entry->fields[insn_flags])) {
2030 lf_printf(file, "\n");
2031 lf_printf(file, "/* Validate: FP hardware exists */\n");
2032 lf_printf(file, "if (CURRENT_FLOATING_POINT != HARD_FLOATING_POINT)\n");
2033 lf_indent(file, +2);
2034 lf_print_idecode_illegal(file);
2035 lf_indent(file, -2);
2039 /* Validate: Floating Point available
2041 If floating point is not available, we enter a floating point
2042 unavailable interrupt into the cache instead of the instruction
2045 The PowerPC spec requires a CSI after MSR[FP] is changed and when
2046 ever a CSI occures we flush the instruction cache. */
2049 if (it_is("f", instruction->file_entry->fields[insn_flags])) {
2050 lf_printf(file, "\n");
2051 lf_printf(file, "/* Validate: FP available according to MSR[FP] */\n");
2052 lf_printf(file, "if (!IS_FP_AVAILABLE(processor))\n");
2053 lf_indent(file, +2);
2054 lf_print_idecode_floating_point_unavailable(file);
2055 lf_indent(file, -2);
2062 lf_print_c_cracker(lf *file,
2064 insn_bits *expanded_bits,
2065 opcode_field *opcodes)
2068 /* function header */
2069 lf_printf(file, "{\n");
2070 lf_indent(file, +2);
2072 lf_print_my_prefix(file,
2073 instruction->file_entry,
2074 1/*putting-value-in-cache*/);
2076 lf_print_ptrace(file,
2077 1/*putting-value-in-cache*/);
2079 lf_print_c_validate(file, instruction, opcodes);
2081 lf_printf(file, "\n");
2082 lf_printf(file, "{\n");
2083 lf_indent(file, +2);
2084 lf_print_c_extractions(file,
2087 0/*get_value_from_cache*/,
2088 1/*put_value_in_cache*/);
2089 lf_indent(file, -2);
2090 lf_printf(file, "}\n");
2092 /* return the function propper (main sorts this one out) */
2093 lf_printf(file, "\n");
2094 lf_printf(file, "/* semantic routine */\n");
2095 table_entry_lf_c_line_nr(file, instruction->file_entry);
2096 lf_printf(file, "return ");
2097 lf_print_function_name(file,
2098 instruction->file_entry->fields[insn_name],
2100 function_name_prefix_semantics);
2101 lf_printf(file, ";\n");
2103 lf_print_lf_c_line_nr(file);
2104 lf_indent(file, -2);
2105 lf_printf(file, "}\n");
2110 lf_print_c_semantic(lf *file,
2112 insn_bits *expanded_bits,
2113 opcode_field *opcodes)
2116 lf_printf(file, "{\n");
2117 lf_indent(file, +2);
2119 lf_print_my_prefix(file,
2120 instruction->file_entry,
2121 0/*not putting value in cache*/);
2122 lf_printf(file, "unsigned_word nia = cia + %d;\n", insn_size / 8);
2124 lf_printf(file, "\n");
2125 lf_print_c_extractions(file,
2128 idecode_cache/*get_value_from_cache*/,
2129 0/*put_value_in_cache*/);
2131 lf_print_ptrace(file,
2132 0/*put_value_in_cache*/);
2134 /* validate the instruction, if a cache this has already been done */
2136 lf_print_c_validate(file, instruction, opcodes);
2138 /* generate the profiling call - this is delayed until after the
2139 instruction has been verified */
2140 lf_printf(file, "\n");
2141 lf_printf(file, "if (WITH_MON & MONITOR_INSTRUCTION_ISSUE) {\n");
2142 lf_printf(file, " mon_issue(");
2143 lf_print_function_name(file,
2144 instruction->file_entry->fields[insn_name],
2146 function_name_prefix_itable);
2147 lf_printf(file, ", processor, cia);\n");
2148 lf_printf(file, "}\n");
2149 lf_printf(file, "\n");
2151 /* generate the code (or at least something */
2152 if (instruction->file_entry->annex != NULL) {
2154 lf_printf(file, "\n");
2155 table_entry_lf_c_line_nr(file, instruction->file_entry);
2156 lf_printf(file, "{\n");
2157 lf_indent(file, +2);
2158 lf_print_c_code(file, instruction->file_entry->annex);
2159 lf_indent(file, -2);
2160 lf_printf(file, "}\n");
2161 lf_print_lf_c_line_nr(file);
2163 else if (it_is("nop", instruction->file_entry->fields[insn_flags])) {
2164 lf_print_lf_c_line_nr(file);
2166 else if (it_is("f", instruction->file_entry->fields[insn_flags])) {
2167 /* unimplemented floating point instruction - call for assistance */
2168 lf_printf(file, "\n");
2169 lf_printf(file, "/* unimplemented floating point instruction - call for assistance */\n");
2170 table_entry_lf_c_line_nr(file, instruction->file_entry);
2171 lf_putstr(file, "floating_point_assist_interrupt(processor, cia);\n");
2172 lf_print_lf_c_line_nr(file);
2175 /* abort so it is implemented now */
2176 table_entry_lf_c_line_nr(file, instruction->file_entry);
2177 lf_putstr(file, "error(\"%s: unimplemented, cia=0x%x\\n\", my_prefix, cia);\n");
2178 lf_print_lf_c_line_nr(file);
2179 lf_printf(file, "\n");
2182 lf_printf(file, "return nia;\n");
2183 lf_indent(file, -2);
2184 lf_printf(file, "}\n");
2188 lf_print_c_semantic_function(lf *file,
2190 insn_bits *expanded_bits,
2191 opcode_field *opcodes,
2192 int is_inline_function)
2195 /* build the semantic routine to execute the instruction */
2196 lf_print_semantic_function_header(file,
2197 instruction->file_entry->fields[insn_name],
2199 1/*is-function-definition*/,
2200 is_inline_function);
2201 lf_print_c_semantic(file,
2209 semantics_c_leaf(insn_table *entry,
2213 lf *file = (lf*)data;
2214 ASSERT(entry->nr_insn == 1
2215 && entry->opcode == NULL
2216 && entry->parent != NULL
2217 && entry->parent->opcode != NULL);
2218 lf_print_c_semantic_function(file,
2220 entry->expanded_bits,
2221 entry->parent->opcode,
2222 !idecode_cache && entry->parent->opcode_rule->use_switch);
2226 semantics_c_insn(insn_table *table,
2230 lf *file = (lf*)data;
2231 lf_print_c_semantic_function(file, instruction,
2233 0/*isnt_inline_function*/);
2237 semantics_c_function(insn_table *table,
2239 table_entry *function)
2241 lf *file = (lf*)data;
2242 if (function->fields[function_type] == NULL
2243 || function->fields[function_type][0] == '\0') {
2244 lf_print_semantic_function_header(file,
2245 function->fields[function_name],
2247 1/*is function definition*/,
2248 1/*is inline function*/);
2251 lf_printf(file, "\n");
2252 lf_printf(file, "INLINE_SEMANTICS %s\n%s(%s)\n",
2253 function->fields[function_type],
2254 function->fields[function_name],
2255 function->fields[function_param]);
2257 table_entry_lf_c_line_nr(file, function);
2258 lf_printf(file, "{\n");
2259 lf_indent(file, +2);
2260 lf_print_c_code(file, function->annex);
2261 lf_indent(file, -2);
2262 lf_printf(file, "}\n");
2263 lf_print_lf_c_line_nr(file);
2269 gen_semantics_c(insn_table *table, lf *file)
2271 lf_print_copyleft(file);
2272 lf_printf(file, "\n");
2273 lf_printf(file, "#ifndef _SEMANTICS_C_\n");
2274 lf_printf(file, "#define _SEMANTICS_C_\n");
2275 lf_printf(file, "\n");
2276 lf_printf(file, "#ifndef STATIC_INLINE_SEMANTICS\n");
2277 lf_printf(file, "#define STATIC_INLINE_SEMANTICS STATIC_INLINE\n");
2278 lf_printf(file, "#endif\n");
2279 lf_printf(file, "\n");
2280 lf_printf(file, "#include \"cpu.h\"\n");
2281 lf_printf(file, "#include \"idecode.h\"\n");
2282 lf_printf(file, "#include \"semantics.h\"\n");
2283 lf_printf(file, "\n");
2285 /* output a definition (c-code) for all functions */
2286 insn_table_traverse_function(table,
2288 semantics_c_function);
2290 /* output a definition (c-code) for all instructions */
2291 if (idecode_expand_semantics)
2292 insn_table_traverse_tree(table,
2298 NULL); /* padding */
2300 insn_table_traverse_insn(table,
2304 lf_printf(file, "\n");
2305 lf_printf(file, "#endif /* _SEMANTICS_C_ */\n");
2309 /****************************************************************/
2312 gen_idecode_h(insn_table *table, lf *file)
2314 lf_print_copyleft(file);
2315 lf_printf(file, "\n");
2316 lf_printf(file, "#ifndef _IDECODE_H_\n");
2317 lf_printf(file, "#define _IDECODE_H_\n");
2318 lf_printf(file, "\n");
2319 lf_printf(file, "#ifndef INLINE_IDECODE\n");
2320 lf_printf(file, "#define INLINE_IDECODE\n");
2321 lf_printf(file, "#endif\n");
2322 lf_printf(file, "\n");
2323 lf_printf(file, "#include \"idecode_expression.h\"\n");
2324 lf_printf(file, "#include \"idecode_fields.h\"\n");
2325 lf_printf(file, "#include \"idecode_branch.h\"\n");
2326 lf_printf(file, "\n");
2327 lf_printf(file, "#include \"icache.h\"\n");
2328 lf_printf(file, "\n");
2329 lf_printf(file, "typedef unsigned_word idecode_semantic\n(%s);\n",
2330 (idecode_cache ? cache_semantic_formal : semantic_formal));
2331 lf_printf(file, "\n");
2333 lf_printf(file, "INLINE_IDECODE idecode_semantic *idecode\n(%s);\n",
2334 cache_idecode_formal);
2336 lf_printf(file, "INLINE_IDECODE unsigned_word idecode_issue\n(%s);\n",
2338 lf_printf(file, "\n");
2339 lf_printf(file, "#endif /* _IDECODE_H_ */\n");
2343 /****************************************************************/
2347 idecode_table_start(insn_table *table,
2351 lf *file = (lf*)data;
2353 /* start of the table */
2354 if (!table->opcode_rule->use_switch) {
2355 lf_printf(file, "\n");
2356 lf_printf(file, "static idecode_table_entry ");
2357 lf_print_table_name(file, table);
2358 lf_printf(file, "[] = {\n");
2363 idecode_table_leaf(insn_table *entry,
2367 lf *file = (lf*)data;
2368 ASSERT(entry->parent != NULL);
2371 /* add an entry to the table */
2372 if (!entry->parent->opcode_rule->use_switch) {
2373 if (entry->opcode == NULL) {
2374 /* table leaf entry */
2375 lf_printf(file, " /*%d*/ { 0, 0, ", entry->opcode_nr);
2376 lf_print_function_name(file,
2377 entry->insns->file_entry->fields[insn_name],
2378 entry->expanded_bits,
2380 ? function_name_prefix_idecode
2381 : function_name_prefix_semantics));
2382 lf_printf(file, " },\n");
2384 else if (entry->opcode_rule->use_switch) {
2385 /* table calling switch statement */
2386 lf_printf(file, " /*%d*/ { 0, 0, ",
2388 lf_print_table_name(file, entry);
2389 lf_printf(file, " },\n");
2392 /* table `calling' another table */
2393 lf_printf(file, " /*%d*/ { ", entry->opcode_nr);
2394 if (entry->opcode->is_boolean)
2395 lf_printf(file, "MASK32(%d,%d), 0, ",
2396 i2target(hi_bit_nr, entry->opcode->first),
2397 i2target(hi_bit_nr, entry->opcode->last));
2399 lf_printf(file, "%d, MASK32(%d,%d), ",
2400 insn_size - entry->opcode->last - 1,
2401 i2target(hi_bit_nr, entry->opcode->first),
2402 i2target(hi_bit_nr, entry->opcode->last));
2403 lf_print_table_name(file, entry);
2404 lf_printf(file, " },\n");
2410 idecode_table_end(insn_table *table,
2414 lf *file = (lf*)data;
2417 if (!table->opcode_rule->use_switch) {
2418 lf_printf(file, "};\n");
2423 idecode_table_padding(insn_table *table,
2428 lf *file = (lf*)data;
2431 if (!table->opcode_rule->use_switch) {
2432 lf_printf(file, " /*%d*/ { 0, 0, %s_illegal },\n",
2433 opcode_nr, (idecode_cache ? "idecode" : "semantic"));
2438 /****************************************************************/
2441 void lf_print_idecode_switch
2447 idecode_switch_start(insn_table *table,
2451 lf *file = (lf*)data;
2453 ASSERT(table->opcode_rule->use_switch);
2455 lf_printf(file, "switch (EXTRACTED32(instruction, %d, %d)) {\n",
2456 i2target(hi_bit_nr, table->opcode->first),
2457 i2target(hi_bit_nr, table->opcode->last));
2462 idecode_switch_leaf(insn_table *entry,
2466 lf *file = (lf*)data;
2467 ASSERT(entry->parent != NULL);
2469 ASSERT(entry->parent->opcode_rule->use_switch);
2470 ASSERT(entry->parent->opcode);
2472 if (!entry->parent->opcode->is_boolean
2473 || entry->opcode_nr == 0)
2474 lf_printf(file, "case %d:\n", entry->opcode_nr);
2476 lf_printf(file, "default:\n");
2477 lf_indent(file, +2);
2479 if (entry->opcode == NULL) {
2480 /* switch calling leaf */
2481 lf_printf(file, "return ");
2482 lf_print_function_name(file,
2483 entry->insns->file_entry->fields[insn_name],
2484 entry->expanded_bits,
2486 ? function_name_prefix_idecode
2487 : function_name_prefix_semantics));
2489 lf_printf(file, "(%s);\n", cache_idecode_actual);
2491 lf_printf(file, "(%s);\n", semantic_actual);
2493 else if (entry->opcode_rule->use_switch) {
2494 /* switch calling switch */
2495 lf_print_idecode_switch(file, entry);
2498 /* switch looking up a table */
2499 lf_print_idecode_table(file, entry);
2501 lf_printf(file, "break;\n");
2503 lf_indent(file, -2);
2508 lf_print_idecode_switch_illegal(lf *file)
2510 lf_indent(file, +2);
2511 lf_print_idecode_illegal(file);
2512 lf_printf(file, "break;\n");
2513 lf_indent(file, -2);
2517 idecode_switch_end(insn_table *table,
2521 lf *file = (lf*)data;
2523 ASSERT(table->opcode_rule->use_switch);
2524 ASSERT(table->opcode);
2526 if (table->opcode_rule->use_switch == 1
2527 && !table->opcode->is_boolean) {
2528 lf_printf(file, "default:\n");
2529 lf_print_idecode_switch_illegal(file);
2531 lf_printf(file, "}\n");
2535 idecode_switch_padding(insn_table *table,
2540 lf *file = (lf*)data;
2543 ASSERT(table->opcode_rule->use_switch);
2545 if (table->opcode_rule->use_switch > 1) {
2546 lf_printf(file, "case %d:\n", opcode_nr);
2547 lf_print_idecode_switch_illegal(file);
2553 lf_print_idecode_switch(lf *file,
2556 insn_table_traverse_tree(table,
2559 idecode_switch_start,
2560 idecode_switch_leaf,
2562 idecode_switch_padding);
2567 lf_print_idecode_switch_function_header(lf *file,
2569 int is_function_definition)
2571 lf_printf(file, "\n");
2572 lf_printf(file, "static ");
2574 lf_printf(file, "idecode_semantic *");
2576 lf_printf(file, "unsigned_word");
2577 if (is_function_definition)
2578 lf_printf(file, "\n");
2580 lf_printf(file, " ");
2581 lf_print_table_name(file, table);
2582 lf_printf(file, "\n(%s)",
2583 (idecode_cache ? cache_idecode_formal : semantic_formal));
2584 if (!is_function_definition)
2585 lf_printf(file, ";");
2586 lf_printf(file, "\n");
2591 idecode_declare_if_switch(insn_table *table,
2595 lf *file = (lf*)data;
2597 if (table->opcode_rule->use_switch
2598 && table->parent != NULL /* don't declare the top one yet */
2599 && !table->parent->opcode_rule->use_switch) {
2600 lf_print_idecode_switch_function_header(file,
2602 0/*isnt function definition*/);
2608 idecode_expand_if_switch(insn_table *table,
2612 lf *file = (lf*)data;
2614 if (table->opcode_rule->use_switch
2615 && table->parent != NULL /* don't expand the top one yet */
2616 && !table->parent->opcode_rule->use_switch) {
2617 lf_print_idecode_switch_function_header(file,
2619 1/*is function definition*/);
2620 lf_printf(file, "{\n");
2622 lf_indent(file, +2);
2623 lf_print_idecode_switch(file, table);
2624 lf_indent(file, -2);
2626 lf_printf(file, "}\n");
2632 lf_print_c_cracker_function(lf *file,
2634 insn_bits *expanded_bits,
2635 opcode_field *opcodes,
2636 int is_inline_function)
2638 /* if needed, generate code to enter this routine into a cache */
2639 lf_printf(file, "\n");
2640 lf_printf(file, "STATIC_IDECODE idecode_semantic *\n");
2641 lf_print_function_name(file,
2642 instruction->file_entry->fields[insn_name],
2644 function_name_prefix_idecode);
2645 lf_printf(file, "\n(%s)\n", cache_idecode_formal);
2647 lf_print_c_cracker(file,
2654 idecode_crack_leaf(insn_table *entry,
2658 lf *file = (lf*)data;
2659 ASSERT(entry->nr_insn == 1
2660 && entry->opcode == NULL
2661 && entry->parent != NULL
2662 && entry->parent->opcode != NULL
2663 && entry->parent->opcode_rule != NULL);
2664 lf_print_c_cracker_function(file,
2666 entry->expanded_bits,
2668 entry->parent->opcode_rule->use_switch);
2672 idecode_crack_insn(insn_table *entry,
2676 lf *file = (lf*)data;
2677 lf_print_c_cracker_function(file,
2681 0/*isnt inline function*/);
2685 idecode_c_internal_function(insn_table *table,
2687 table_entry *function)
2689 lf *file = (lf*)data;
2690 ASSERT(idecode_cache != 0);
2691 if (it_is("internal", function->fields[insn_flags])) {
2692 lf_printf(file, "\n");
2693 lf_printf(file, "STATIC_INLINE_IDECODE idecode_semantic *\n");
2694 lf_print_function_name(file,
2695 function->fields[insn_name],
2697 function_name_prefix_idecode);
2698 lf_printf(file, "\n(%s)\n", cache_idecode_formal);
2699 lf_printf(file, "{\n");
2700 lf_indent(file, +2);
2701 lf_printf(file, "/* semantic routine */\n");
2702 table_entry_lf_c_line_nr(file, function);
2703 lf_printf(file, "return ");
2704 lf_print_function_name(file,
2705 function->fields[insn_name],
2707 function_name_prefix_semantics);
2708 lf_printf(file, ";\n");
2710 lf_print_lf_c_line_nr(file);
2711 lf_indent(file, -2);
2712 lf_printf(file, "}\n");
2717 /****************************************************************/
2720 gen_idecode_c(insn_table *table, lf *file)
2725 lf_print_copyleft(file);
2726 lf_printf(file, "\n");
2727 lf_printf(file, "\n");
2728 lf_printf(file, "#ifndef _IDECODE_C_\n");
2729 lf_printf(file, "#define _IDECODE_C_\n");
2730 lf_printf(file, "\n");
2731 lf_printf(file, "#ifndef STATIC_INLINE_IDECODE\n");
2732 lf_printf(file, "#define STATIC_INLINE_IDECODE STATIC_INLINE\n");
2733 lf_printf(file, "#endif\n");
2734 lf_printf(file, "\n");
2735 lf_printf(file, "#ifndef STATIC_IDECODE\n");
2736 lf_printf(file, "#define STATIC_IDECODE\n");
2737 lf_printf(file, "#endif\n");
2738 lf_printf(file, "\n");
2739 lf_printf(file, "#include \"cpu.h\"\n");
2740 lf_printf(file, "#include \"idecode.h\"\n");
2741 lf_printf(file, "#include \"semantics.h\"\n");
2742 lf_printf(file, "\n");
2743 lf_printf(file, "\n");
2744 lf_printf(file, "typedef idecode_semantic *idecode_crack\n(%s);\n",
2745 (idecode_cache ? cache_idecode_formal : semantic_formal));
2746 lf_printf(file, "\n");
2747 lf_printf(file, "typedef struct _idecode_table_entry {\n");
2748 lf_printf(file, " unsigned shift;\n");
2749 lf_printf(file, " unsigned mask;\n");
2750 lf_printf(file, " void *function_or_table;\n");
2751 lf_printf(file, "} idecode_table_entry;\n");
2752 lf_printf(file, "\n");
2753 lf_printf(file, "\n");
2755 /* output `internal' invalid/floating-point unavailable functions
2757 if (idecode_cache) {
2758 insn_table_traverse_function(table,
2760 idecode_c_internal_function);
2763 /* output cracking functions where needed */
2764 if (idecode_cache) {
2765 if (idecode_expand_semantics)
2766 insn_table_traverse_tree(table,
2774 insn_table_traverse_insn(table,
2776 idecode_crack_insn);
2779 /* output switch function declarations where needed by tables */
2780 insn_table_traverse_tree(table,
2783 idecode_declare_if_switch, /* START */
2786 /* output tables where needed */
2787 for (depth = insn_table_depth(table);
2790 insn_table_traverse_tree(table,
2793 idecode_table_start,
2796 idecode_table_padding);
2799 /* output switch functions where needed */
2800 insn_table_traverse_tree(table,
2803 idecode_expand_if_switch, /* START */
2806 /* output the main idecode routine */
2807 lf_printf(file, "\n");
2809 lf_printf(file, "INLINE_IDECODE idecode_semantic *\nidecode\n(%s)\n",
2810 cache_idecode_formal);
2812 lf_printf(file, "INLINE_IDECODE unsigned_word\nidecode_issue\n(%s)\n",
2814 lf_printf(file, "{\n");
2815 lf_indent(file, +2);
2816 if (table->opcode_rule->use_switch)
2817 lf_print_idecode_switch(file, table);
2819 lf_print_idecode_table(file, table);
2820 lf_indent(file, -2);
2821 lf_printf(file, "}\n");
2822 lf_printf(file, "\n");
2823 lf_printf(file, "#endif /* _IDECODE_C_ */\n");
2827 /****************************************************************/
2830 itable_h_insn(insn_table *entry,
2834 lf *file = (lf*)data;
2835 lf_printf(file, " ");
2836 lf_print_function_name(file,
2837 instruction->file_entry->fields[insn_name],
2839 function_name_prefix_itable);
2840 lf_printf(file, ",\n");
2845 gen_itable_h(insn_table *table, lf *file)
2848 lf_print_copyleft(file);
2849 lf_printf(file, "\n");
2850 lf_printf(file, "#ifndef _ITABLE_H_\n");
2851 lf_printf(file, "#define _ITABLE_H_\n");
2852 lf_printf(file, "\n");
2853 lf_printf(file, "#ifndef INLINE_ITABLE\n");
2854 lf_printf(file, "#define INLINE_ITABLE\n");
2855 lf_printf(file, "#endif\n");
2856 lf_printf(file, "\n");
2857 lf_printf(file, "\n");
2859 /* output an enumerated type for each instruction */
2860 lf_printf(file, "typedef enum {\n");
2861 insn_table_traverse_insn(table,
2864 lf_printf(file, " nr_itable_entries,\n");
2865 lf_printf(file, "} itable_index;\n");
2866 lf_printf(file, "\n");
2868 /* output the table that contains the actual instruction info */
2869 lf_printf(file, "typedef struct _itable_instruction_info {\n");
2870 lf_printf(file, " itable_index nr;\n");
2871 lf_printf(file, " char *format;\n");
2872 lf_printf(file, " char *form;\n");
2873 lf_printf(file, " char *flags;\n");
2874 lf_printf(file, " char *mnemonic;\n");
2875 lf_printf(file, " char *name;\n");
2876 lf_printf(file, "} itable_info;\n");
2877 lf_printf(file, "\n");
2878 lf_printf(file, "extern itable_info itable[nr_itable_entries];\n");
2880 lf_printf(file, "\n");
2881 lf_printf(file, "#endif /* _ITABLE_C_ */\n");
2885 /****************************************************************/
2888 itable_c_insn(insn_table *entry,
2892 lf *file = (lf*)data;
2893 char **fields = instruction->file_entry->fields;
2894 lf_printf(file, " { ");
2895 lf_print_function_name(file,
2896 instruction->file_entry->fields[insn_name],
2898 function_name_prefix_itable);
2899 lf_printf(file, ",\n");
2900 lf_printf(file, " \"%s\",\n", fields[insn_format]);
2901 lf_printf(file, " \"%s\",\n", fields[insn_form]);
2902 lf_printf(file, " \"%s\",\n", fields[insn_flags]);
2903 lf_printf(file, " \"%s\",\n", fields[insn_mnemonic]);
2904 lf_printf(file, " \"%s\",\n", fields[insn_name]);
2905 lf_printf(file, " },\n");
2910 gen_itable_c(insn_table *table, lf *file)
2913 lf_print_copyleft(file);
2914 lf_printf(file, "\n");
2915 lf_printf(file, "#ifndef _ITABLE_C_\n");
2916 lf_printf(file, "#define _ITABLE_C_\n");
2917 lf_printf(file, "\n");
2918 lf_printf(file, "#ifndef STATIC_INLINE_ITABLE\n");
2919 lf_printf(file, "#define STATIC_INLINE_ITABLE STATIC_INLINE\n");
2920 lf_printf(file, "#endif\n");
2921 lf_printf(file, "\n");
2922 lf_printf(file, "#include \"itable.h\"\n");
2923 lf_printf(file, "\n");
2925 /* output the table that contains the actual instruction info */
2926 lf_printf(file, "itable_info itable[nr_itable_entries] = {\n");
2927 insn_table_traverse_insn(table,
2930 lf_printf(file, "};\n");
2931 lf_printf(file, "\n");
2933 lf_printf(file, "\n");
2934 lf_printf(file, "#endif /* _ITABLE_C_ */\n");
2937 /****************************************************************/
2940 model_c_or_h_data(insn_table *table,
2945 table_entry_lf_c_line_nr(file, data);
2946 lf_print_c_code(file, data->annex);
2947 lf_print_lf_c_line_nr(file);
2948 lf_printf(file, "\n");
2953 model_c_or_h_function(insn_table *entry,
2955 table_entry *function,
2958 if (function->fields[function_type] == NULL
2959 || function->fields[function_type][0] == '\0') {
2960 error("Model function type not specified for %s", function->fields[function_name]);
2963 lf_printf(file, "\n");
2964 lf_printf(file, "%s %s %s\n(%s);\n",
2966 function->fields[function_type],
2967 function->fields[function_name],
2968 function->fields[function_param]);
2970 lf_printf(file, "\n");
2974 gen_model_h(insn_table *table, lf *file)
2980 int model_create_p = 0;
2981 int model_init_p = 0;
2982 int model_halt_p = 0;
2983 int model_mon_info_p = 0;
2984 int model_mon_info_free_p = 0;
2986 lf_print_copyleft(file);
2987 lf_printf(file, "\n");
2988 lf_printf(file, "#ifndef _MODEL_H_\n");
2989 lf_printf(file, "#define _MODEL_H_\n");
2990 lf_printf(file, "\n");
2992 for(macro = model_macros; macro; macro = macro->next) {
2993 model_c_or_h_data(table, file, macro->file_entry);
2996 lf_printf(file, "#ifndef INLINE_MODEL\n");
2997 lf_printf(file, "#define INLINE_MODEL\n");
2998 lf_printf(file, "#endif\n");
2999 lf_printf(file, "#ifndef STATIC_INLINE_MODEL\n");
3000 lf_printf(file, "#define STATIC_INLINE_MODEL STATIC_INLINE\n");
3001 lf_printf(file, "#endif\n");
3002 lf_printf(file, "\n");
3003 lf_printf(file, "#ifndef STATIC_MODEL\n");
3004 lf_printf(file, "#define STATIC_MODEL\n");
3005 lf_printf(file, "#endif\n");
3006 lf_printf(file, "\n");
3007 lf_printf(file, "#ifndef EXTERN_MODEL\n");
3008 lf_printf(file, "#define EXTERN_MODEL extern\n");
3009 lf_printf(file, "#endif\n");
3010 lf_printf(file, "\n");
3012 lf_printf(file, "typedef enum _model_enum {\n");
3013 lf_printf(file, " MODEL_NONE,\n");
3014 for (model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
3015 lf_printf(file, " MODEL_%s,\n", model_ptr->name);
3017 lf_printf(file, " nr_models\n");
3018 lf_printf(file, "} model_enum;\n");
3019 lf_printf(file, "\n");
3021 lf_printf(file, "#define DEFAULT_MODEL MODEL_%s\n", (models) ? models->name : "NONE");
3022 lf_printf(file, "\n");
3024 lf_printf(file, "typedef struct _model_data model_data;\n");
3025 lf_printf(file, "typedef struct _model_time model_time;\n");
3026 lf_printf(file, "\n");
3028 lf_printf(file, "extern model_enum current_model;\n");
3029 lf_printf(file, "EXTERN_MODEL const char *model_name[ (int)nr_models ];\n");
3030 lf_printf(file, "EXTERN_MODEL const char *const *const model_func_unit_name[ (int)nr_models ];\n");
3031 lf_printf(file, "EXTERN_MODEL const model_time *const model_time_mapping[ (int)nr_models ];\n");
3032 lf_printf(file, "\n");
3034 for(insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next) {
3035 model_c_or_h_function(table, file, insn_ptr->file_entry, "INLINE_MODEL");
3036 name = insn_ptr->file_entry->fields[function_name];
3037 if (strcmp (name, "model_create") == 0)
3039 else if (strcmp (name, "model_init") == 0)
3041 else if (strcmp (name, "model_halt") == 0)
3043 else if (strcmp (name, "model_mon_info") == 0)
3044 model_mon_info_p = 1;
3045 else if (strcmp (name, "model_mon_info_free") == 0)
3046 model_mon_info_free_p = 1;
3049 if (!model_create_p) {
3050 lf_printf(file, "INLINE_MODEL model_data *model_create\n");
3051 lf_printf(file, "(cpu *processor);\n");
3052 lf_printf(file, "\n");
3055 if (!model_init_p) {
3056 lf_printf(file, "INLINE_MODEL void model_init\n");
3057 lf_printf(file, "(model_data *model_ptr);\n");
3058 lf_printf(file, "\n");
3061 if (!model_halt_p) {
3062 lf_printf(file, "INLINE_MODEL void model_halt\n");
3063 lf_printf(file, "(model_data *model_ptr);\n");
3064 lf_printf(file, "\n");
3067 if (!model_mon_info_p) {
3068 lf_printf(file, "INLINE_MODEL model_print *model_mon_info\n");
3069 lf_printf(file, "(model_data *model_ptr);\n");
3070 lf_printf(file, "\n");
3073 if (!model_mon_info_free_p) {
3074 lf_printf(file, "INLINE_MODEL void model_mon_info_free\n");
3075 lf_printf(file, "(model_data *model_ptr,\n");
3076 lf_printf(file, " model_print *info_ptr);\n");
3077 lf_printf(file, "\n");
3080 lf_printf(file, "INLINE_MODEL void model_set\n");
3081 lf_printf(file, "(const char *name);\n");
3082 lf_printf(file, "\n");
3083 lf_printf(file, "#endif /* _MODEL_H_ */\n");
3086 /****************************************************************/
3088 typedef struct _model_c_passed_data model_c_passed_data;
3089 struct _model_c_passed_data {
3095 model_c_insn(insn_table *entry,
3099 model_c_passed_data *data_ptr = (model_c_passed_data *)data;
3100 lf *file = data_ptr->file;
3101 char *current_name = data_ptr->model_ptr->printable_name;
3102 table_model_entry *model_ptr = instruction->file_entry->model_first;
3105 if (model_ptr->fields[insn_model_name] == current_name) {
3106 lf_printf(file, " { %-*s }, /* %s */\n",
3107 max_model_fields_len,
3108 model_ptr->fields[insn_model_fields],
3109 instruction->file_entry->fields[insn_name]);
3113 model_ptr = model_ptr->next;
3116 lf_printf(file, " { %-*s }, /* %s */\n",
3117 max_model_fields_len,
3118 data_ptr->model_ptr->insn_default,
3119 instruction->file_entry->fields[insn_name]);
3123 model_c_function(insn_table *table,
3125 table_entry *function,
3128 if (function->fields[function_type] == NULL
3129 || function->fields[function_type][0] == '\0') {
3130 error("Model function return type not specified for %s", function->fields[function_name]);
3133 lf_printf(file, "\n");
3134 lf_printf(file, "%s %s\n%s(%s)\n",
3136 function->fields[function_type],
3137 function->fields[function_name],
3138 function->fields[function_param]);
3140 table_entry_lf_c_line_nr(file, function);
3141 lf_printf(file, "{\n");
3142 if (function->annex) {
3143 lf_indent(file, +2);
3144 lf_print_c_code(file, function->annex);
3145 lf_indent(file, -2);
3147 lf_printf(file, "}\n");
3148 lf_print_lf_c_line_nr(file);
3149 lf_printf(file, "\n");
3153 gen_model_c(insn_table *table, lf *file)
3158 int model_create_p = 0;
3159 int model_init_p = 0;
3160 int model_halt_p = 0;
3161 int model_mon_info_p = 0;
3162 int model_mon_info_free_p = 0;
3164 lf_print_copyleft(file);
3165 lf_printf(file, "\n");
3166 lf_printf(file, "#ifndef _MODEL_C_\n");
3167 lf_printf(file, "#define _MODEL_C_\n");
3168 lf_printf(file, "\n");
3169 lf_printf(file, "#include \"cpu.h\"\n");
3170 lf_printf(file, "#include \"mon.h\"\n");
3171 lf_printf(file, "\n");
3172 lf_printf(file, "#ifdef HAVE_STDLIB_H\n");
3173 lf_printf(file, "#include <stdlib.h>\n");
3174 lf_printf(file, "#endif\n");
3175 lf_printf(file, "\n");
3177 for(insn_ptr = model_data; insn_ptr; insn_ptr = insn_ptr->next) {
3178 model_c_or_h_data(table, file, insn_ptr->file_entry);
3181 for(insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next) {
3182 model_c_or_h_function(table, file, insn_ptr->file_entry, "STATIC_MODEL");
3185 for(insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next) {
3186 model_c_or_h_function(table, file, insn_ptr->file_entry, "STATIC_INLINE_MODEL");
3189 for(insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next) {
3190 model_c_function(table, file, insn_ptr->file_entry, "STATIC_MODEL");
3193 for(insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next) {
3194 model_c_function(table, file, insn_ptr->file_entry, "STATIC_INLINE_MODEL");
3197 for(insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next) {
3198 model_c_function(table, file, insn_ptr->file_entry, "INLINE_MODEL");
3199 name = insn_ptr->file_entry->fields[function_name];
3200 if (strcmp (name, "model_create") == 0)
3202 else if (strcmp (name, "model_init") == 0)
3204 else if (strcmp (name, "model_halt") == 0)
3206 else if (strcmp (name, "model_mon_info") == 0)
3207 model_mon_info_p = 1;
3208 else if (strcmp (name, "model_mon_info_free") == 0)
3209 model_mon_info_free_p = 1;
3212 if (!model_create_p) {
3213 lf_printf(file, "INLINE_MODEL model_data *model_create(cpu *processor)\n");
3214 lf_printf(file, "{\n");
3215 lf_printf(file, " return (model_data *)0;\n");
3216 lf_printf(file, "}\n");
3217 lf_printf(file, "\n");
3220 if (!model_init_p) {
3221 lf_printf(file, "INLINE_MODEL void model_init(model_data *model_ptr)\n");
3222 lf_printf(file, "{\n");
3223 lf_printf(file, "}\n");
3224 lf_printf(file, "\n");
3227 if (!model_halt_p) {
3228 lf_printf(file, "INLINE_MODEL void model_halt(model_data *model_ptr)\n");
3229 lf_printf(file, "{\n");
3230 lf_printf(file, "}\n");
3231 lf_printf(file, "\n");
3234 if (!model_mon_info_p) {
3235 lf_printf(file, "INLINE_MODEL model_print *model_mon_info(model_data *model_ptr)\n");
3236 lf_printf(file, "{\n");
3237 lf_printf(file, " return (model_print *)0;\n");
3238 lf_printf(file, "}\n");
3239 lf_printf(file, "\n");
3242 if (!model_mon_info_free_p) {
3243 lf_printf(file, "INLINE_MODEL void model_mon_info_free(model_data *model_ptr,\n");
3244 lf_printf(file, " model_print *info_ptr)\n");
3245 lf_printf(file, "{\n");
3246 lf_printf(file, "}\n");
3247 lf_printf(file, "\n");
3250 lf_printf(file, "/* Insn functional unit info */\n");
3251 for(model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
3252 model_c_passed_data data;
3254 lf_printf(file, "static const model_time model_time_%s[] = {\n", model_ptr->name);
3256 data.model_ptr = model_ptr;
3257 insn_table_traverse_insn(table,
3261 lf_printf(file, "};\n");
3262 lf_printf(file, "\n");
3263 lf_printf(file, "\f\n");
3266 lf_printf(file, "STATIC_MODEL const model_time *const model_time_mapping[ (int)nr_models ] = {\n");
3267 lf_printf(file, " (const model_time *const)0,\n");
3268 for(model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
3269 lf_printf(file, " model_time_%s,\n", model_ptr->name);
3271 lf_printf(file, "};\n");
3272 lf_printf(file, "\n");
3274 lf_printf(file, "\f\n");
3275 lf_printf(file, "/* map model enumeration into printable string */\n");
3276 lf_printf(file, "STATIC_MODEL const char *model_name[ (int)nr_models ] = {\n");
3277 lf_printf(file, " \"NONE\",\n");
3278 for (model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
3279 lf_printf(file, " \"%s\",\n", model_ptr->printable_name);
3281 lf_printf(file, "};\n");
3282 lf_printf(file, "\n");
3284 lf_printf(file, "INLINE_MODEL void\n");
3285 lf_printf(file, "model_set(const char *name)\n");
3286 lf_printf(file, "{\n");
3288 lf_printf(file, " model_enum model;\n");
3289 lf_printf(file, " for(model = MODEL_%s; model < nr_models; model++) {\n", models->name);
3290 lf_printf(file, " if(strcmp(name, model_name[model]) == 0) {\n");
3291 lf_printf(file, " current_model = model;\n");
3292 lf_printf(file, " return;\n");
3293 lf_printf(file, " }\n");
3294 lf_printf(file, " }\n");
3295 lf_printf(file, "\n");
3296 lf_printf(file, " error(\"Unknown model '%%s', Models which are known are:%%s\n\",\n");
3297 lf_printf(file, " name,\n");
3298 lf_printf(file, " \"");
3299 for(model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
3300 lf_printf(file, "\\n\\t%s", model_ptr->printable_name);
3302 lf_printf(file, "\");\n");
3304 lf_printf(file, " error(\"No models are currently known about\");\n");
3307 lf_printf(file, "}\n");
3308 lf_printf(file, "\n");
3310 lf_printf(file, "#endif /* _MODEL_C_ */\n");
3314 /****************************************************************/
3322 insn_table *instructions = NULL;
3323 icache_tree *cache_fields = NULL;
3324 char *real_file_name = NULL;
3329 printf(" igen <config-opts> ... <input-opts>... <output-opts>...\n");
3330 printf("Config options:\n");
3331 printf(" -f <filter-out-flag> eg -f 64 to skip 64bit instructions\n");
3332 printf(" -e Expand (duplicate) semantic functions\n");
3333 printf(" -r <icache-size> Generate cracking cache version\n");
3334 printf(" -l Supress line numbering in output files\n");
3335 printf(" -b <bit-size> Set the number of bits in an instruction\n");
3336 printf(" -h <high-bit> Set the nr of the high (msb bit)\n");
3337 printf("Input options (ucase version also dumps loaded table):\n");
3338 printf(" -[Oo] <opcode-rules>\n");
3339 printf(" -[Kk] <cache-rules>\n");
3340 printf(" -[Ii] <instruction-table>\n");
3341 printf("Output options:\n");
3342 printf(" -[Cc] <output-file> output icache.h(C) invalid(c)\n");
3343 printf(" -[Dd] <output-file> output idecode.h(D) idecode.c(d)\n");
3344 printf(" -[Mm] <output-file> output model.h(M) model.c(M)\n");
3345 printf(" -[Ss] <output-file> output schematic.h(S) schematic.c(s)\n");
3346 printf(" -[Tt] <table> output itable.h(T) itable.c(t)\n");
3349 while ((ch = getopt(argc, argv,
3350 "leb:h:r:f:I:i:O:o:K:k:M:m:n:S:s:D:d:T:t:C:")) != -1) {
3351 fprintf(stderr, "\t-%c %s\n", ch, (optarg ? optarg : ""));
3357 idecode_expand_semantics = 1;
3360 idecode_cache = a2i(optarg);
3363 insn_size = a2i(optarg);
3364 ASSERT(insn_size > 0 && insn_size <= max_insn_size
3365 && (hi_bit_nr == insn_size-1 || hi_bit_nr == 0));
3368 hi_bit_nr = a2i(optarg);
3369 ASSERT(hi_bit_nr == insn_size-1 || hi_bit_nr == 0);
3373 filter *new_filter = ZALLOC(filter);
3374 new_filter->flag = strdup(optarg);
3375 new_filter->next = filters;
3376 filters = new_filter;
3381 ASSERT(opcode_table != NULL);
3382 ASSERT(cache_table != NULL);
3383 instructions = insn_table_load_insns(optarg);
3384 fprintf(stderr, "\texpanding ...\n");
3385 insn_table_expand_insns(instructions);
3386 fprintf(stderr, "\tcache fields ...\n");
3387 cache_fields = insn_table_cache_fields(instructions);
3389 dump_traverse(instructions);
3390 dump_insn_table(instructions, 0, 1);
3395 opcode_table = load_opcode_rules(optarg);
3397 dump_opcode_rules(opcode_table, 0);
3401 cache_table = load_cache_rules(optarg);
3403 dump_cache_rules(cache_table, 0);
3406 real_file_name = strdup(optarg);
3418 lf *file = lf_open(optarg, real_file_name, number_lines);
3419 ASSERT(instructions != NULL);
3422 gen_semantics_h(instructions, file);
3425 gen_semantics_c(instructions, file);
3428 gen_idecode_h(instructions, file);
3431 gen_idecode_c(instructions, file);
3434 gen_model_h(instructions, file);
3437 gen_model_c(instructions, file);
3440 gen_itable_h(instructions, file);
3443 gen_itable_c(instructions, file);
3446 gen_icache_h(cache_fields, file);
3451 real_file_name = NULL;
3454 error("unknown option\n");