1 /* The IGEN simulator generator for GDB, the GNU Debugger.
3 Copyright 2002, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
5 Contributed by Andrew Cagney.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 static insn_word_entry *
31 parse_insn_word (line_ref *line, char *string, int word_nr)
34 insn_word_entry *word = ZALLOC (insn_word_entry);
36 /* create a leading sentinal */
37 word->first = ZALLOC (insn_field_entry);
38 word->first->first = -1;
39 word->first->last = -1;
40 word->first->width = 0;
42 /* and a trailing sentinal */
43 word->last = ZALLOC (insn_field_entry);
44 word->last->first = options.insn_bit_size;
45 word->last->last = options.insn_bit_size;
46 word->last->width = 0;
48 /* link them together */
49 word->first->next = word->last;
50 word->last->prev = word->first;
52 /* now work through the formats */
53 chp = skip_spaces (string);
61 insn_field_entry *new_field;
63 /* create / link in the new field */
64 new_field = ZALLOC (insn_field_entry);
65 new_field->next = word->last;
66 new_field->prev = word->last->prev;
67 new_field->next->prev = new_field;
68 new_field->prev->next = new_field;
69 new_field->word_nr = word_nr;
71 /* break out the first field (if present) */
73 chp = skip_to_separator (chp, ".,!");
74 strlen_pos = back_spaces (start_pos, chp) - start_pos;
76 /* break out the second field (if present) */
79 /* assume what was specified was the value (and not the start
80 position). Assume the value length implicitly specifies
82 start_val = start_pos;
83 strlen_val = strlen_pos;
90 chp = skip_spaces (chp);
92 if (*chp == '/' || *chp == '*')
98 while (*chp == '/' || *chp == '*');
100 else if (isalpha (*start_val))
106 while (isalnum (*chp) || *chp == '_');
108 else if (isdigit (*start_val))
114 while (isalnum (*chp));
116 strlen_val = chp - start_val;
117 chp = skip_spaces (chp);
120 error (line, "Empty value field\n");
122 /* break out any conditional fields - { [ "!" | "=" [ <value> | <field-name> } */
123 while (*chp == '!' || *chp == '=')
128 insn_field_cond *new_cond = ZALLOC (insn_field_cond);
130 /* determine the conditional test */
134 new_cond->test = insn_field_cond_eq;
137 new_cond->test = insn_field_cond_ne;
145 chp = skip_spaces (chp);
147 chp = skip_to_separator (chp, "+,:!=");
148 end = back_spaces (start, chp);
151 error (line, "Missing or invalid conditional value\n");
152 new_cond->string = NZALLOC (char, len + 1);
153 strncpy (new_cond->string, start, len);
155 /* determine the conditional type */
156 if (isdigit (*start))
158 /* [ "!" | "=" ] <value> */
159 new_cond->type = insn_field_cond_value;
160 new_cond->value = a2i (new_cond->string);
164 /* [ "!" | "=" ] <field> - check field valid */
165 new_cond->type = insn_field_cond_field;
166 /* new_cond->field is determined in later */
169 /* Only a single `=' is permitted. */
170 if ((new_cond->test == insn_field_cond_eq
171 && new_field->conditions != NULL)
172 || (new_field->conditions != NULL
173 && new_field->conditions->test == insn_field_cond_eq))
174 error (line, "Only single conditional when `=' allowed\n");
178 insn_field_cond **last = &new_field->conditions;
179 while (*last != NULL)
180 last = &(*last)->next;
185 /* NOW verify that the field was finished */
188 chp = skip_spaces (chp + 1);
190 error (line, "empty field\n");
192 else if (*chp != '\0')
194 error (line, "Missing field separator\n");
198 new_field->val_string = NZALLOC (char, strlen_val + 1);
199 strncpy (new_field->val_string, start_val, strlen_val);
200 if (isdigit (new_field->val_string[0]))
204 /* when the length/pos field is omited, an integer field
208 for (i = 0; i < strlen_val; i++)
210 if (new_field->val_string[i] != '0'
211 && new_field->val_string[i] != '1')
212 error (line, "invalid binary field %s\n",
213 new_field->val_string);
214 val = (val << 1) + (new_field->val_string[i] == '1');
216 new_field->val_int = val;
217 new_field->type = insn_field_int;
221 new_field->val_int = a2i (new_field->val_string);
222 new_field->type = insn_field_int;
225 else if (new_field->val_string[0] == '/')
227 new_field->type = insn_field_reserved;
229 else if (new_field->val_string[0] == '*')
231 new_field->type = insn_field_wild;
235 new_field->type = insn_field_string;
236 if (filter_is_member (word->field_names, new_field->val_string))
237 error (line, "Field name %s is duplicated\n",
238 new_field->val_string);
239 filter_parse (&word->field_names, new_field->val_string);
241 if (new_field->type != insn_field_string
242 && new_field->conditions != NULL)
243 error (line, "Conditionals can only be applied to named fields\n");
245 /* the copy the position */
246 new_field->pos_string = NZALLOC (char, strlen_pos + 1);
247 strncpy (new_field->pos_string, start_pos, strlen_pos);
250 new_field->first = new_field->prev->last + 1;
251 if (new_field->first == 0 /* first field */
252 && *chp == '\0' /* no further fields */
253 && new_field->type == insn_field_string)
255 /* A single string without any position, assume that it
256 represents the entire instruction word */
257 new_field->width = options.insn_bit_size;
261 /* No explicit width/position, assume value implicitly
262 supplies the width */
263 new_field->width = strlen_val;
265 new_field->last = new_field->first + new_field->width - 1;
266 if (new_field->last >= options.insn_bit_size)
267 error (line, "Bit position %d exceed instruction bit size (%d)\n",
268 new_field->last, options.insn_bit_size);
270 else if (options.insn_specifying_widths)
272 new_field->first = new_field->prev->last + 1;
273 new_field->width = a2i (new_field->pos_string);
274 new_field->last = new_field->first + new_field->width - 1;
275 if (new_field->last >= options.insn_bit_size)
276 error (line, "Bit position %d exceed instruction bit size (%d)\n",
277 new_field->last, options.insn_bit_size);
281 new_field->first = target_a2i (options.hi_bit_nr,
282 new_field->pos_string);
283 new_field->last = new_field->next->first - 1; /* guess */
284 new_field->width = new_field->last - new_field->first + 1; /* guess */
285 new_field->prev->last = new_field->first - 1; /*fix */
286 new_field->prev->width = new_field->first - new_field->prev->first; /*fix */
290 /* fiddle first/last so that the sentinals disapear */
291 ASSERT (word->first->last < 0);
292 ASSERT (word->last->first >= options.insn_bit_size);
293 word->first = word->first->next;
294 word->last = word->last->prev;
296 /* check that the last field goes all the way to the last bit */
297 if (word->last->last != options.insn_bit_size - 1)
299 if (options.warn.width)
300 options.warning (line, "Instruction format is not %d bits wide\n",
301 options.insn_bit_size);
302 word->last->last = options.insn_bit_size - 1;
305 /* now go over this again, pointing each bit position at a field
308 insn_field_entry *field;
309 for (field = word->first;
310 field->last < options.insn_bit_size; field = field->next)
313 for (i = field->first; i <= field->last; i++)
315 word->bit[i] = ZALLOC (insn_bit_entry);
316 word->bit[i]->field = field;
319 case insn_field_invalid:
323 word->bit[i]->mask = 1;
324 word->bit[i]->value = ((field->val_int
326 (field->last - i))) != 0);
327 case insn_field_reserved:
328 case insn_field_wild:
329 case insn_field_string:
330 /* if we encounter a constant conditional, encode
332 if (field->conditions != NULL
333 && field->conditions->test == insn_field_cond_eq
334 && field->conditions->type == insn_field_cond_value)
336 word->bit[i]->mask = 1;
337 word->bit[i]->value = ((field->conditions->value
339 (field->last - i))) != 0);
352 parse_insn_words (insn_entry * insn, char *formats)
354 insn_word_entry **last_word = &insn->words;
357 /* now work through the formats */
367 insn_word_entry *new_word;
369 /* skip leading spaces */
370 chp = skip_spaces (chp);
372 /* break out the format */
374 chp = skip_to_separator (chp, "+");
375 end_pos = back_spaces (start_pos, chp);
376 strlen_pos = end_pos - start_pos;
378 /* check that something was there */
380 error (insn->line, "missing or empty instruction format\n");
382 /* parse the field */
383 format = NZALLOC (char, strlen_pos + 1);
384 strncpy (format, start_pos, strlen_pos);
385 new_word = parse_insn_word (insn->line, format, insn->nr_words);
387 if (filter_is_common (insn->field_names, new_word->field_names))
388 error (insn->line, "Field name duplicated between two words\n");
389 filter_add (&insn->field_names, new_word->field_names);
392 *last_word = new_word;
393 last_word = &new_word->next;
398 ASSERT (*chp == '+');
402 /* create a quick access array (indexed by word) of the same structure */
405 insn_word_entry *word;
406 insn->word = NZALLOC (insn_word_entry *, insn->nr_words + 1);
407 for (i = 0, word = insn->words;
408 i < insn->nr_words; i++, word = word->next)
409 insn->word[i] = word;
412 /* Go over all fields that have conditionals refering to other
413 fields. Link the fields up. Verify that the two fields have the
414 same size. Verify that the two fields are different */
417 for (i = 0; i < insn->nr_words; i++)
419 insn_word_entry *word = insn->word[i];
421 for (f = word->first; f->last < options.insn_bit_size; f = f->next)
423 insn_field_cond *cond;
424 for (cond = f->conditions; cond != NULL; cond = cond->next)
426 if (cond->type == insn_field_cond_field)
429 if (strcmp (cond->string, f->val_string) == 0)
431 "Conditional `%s' of field `%s' refers to its self\n",
432 cond->string, f->val_string);
433 for (j = 0; j <= i && cond->field == NULL; j++)
435 insn_word_entry *refered_word = insn->word[j];
436 insn_field_entry *refered_field;
437 for (refered_field = refered_word->first;
438 refered_field != NULL && cond->field == NULL;
439 refered_field = refered_field->next)
441 if (refered_field->type == insn_field_string
442 && strcmp (refered_field->val_string,
445 /* found field being refered to by conditonal */
446 cond->field = refered_field;
447 /* check refered to and this field are
449 if (f->width != refered_field->width)
451 "Conditional `%s' of field `%s' should be of size %s\n",
452 cond->string, f->val_string,
453 refered_field->width);
457 if (cond->field == NULL)
459 "Conditional `%s' of field `%s' not yet defined\n",
460 cond->string, f->val_string);
472 insn_record, /* default */
478 string_function_record,
483 model_processor_record,
487 model_function_record,
488 model_internal_record,
492 static const name_map insn_type_map[] = {
493 {"option", option_record},
494 {"cache", cache_record},
495 {"compute", compute_record},
496 {"scratch", scratch_record},
497 {"define", define_record},
498 {"include", include_record},
499 {"%s", string_function_record},
500 {"function", function_record},
501 {"internal", internal_record},
502 {"model", model_processor_record},
503 {"model-macro", model_macro_record},
504 {"model-data", model_data_record},
505 {"model-static", model_static_record},
506 {"model-internal", model_internal_record},
507 {"model-function", model_function_record},
513 record_is_old (table_entry *entry)
515 if (entry->nr_fields > record_type_field
516 && strlen (entry->field[record_type_field]) == 0)
521 static insn_record_type
522 record_type (table_entry *entry)
526 case table_code_entry:
529 case table_colon_entry:
530 if (record_is_old (entry))
533 if (entry->nr_fields > old_record_type_field)
535 int i = name2i (entry->field[old_record_type_field],
541 return unknown_record;
544 else if (entry->nr_fields > record_type_field
545 && entry->field[0][0] == '\0')
548 int i = name2i (entry->field[record_type_field],
553 return insn_record; /* default */
555 return unknown_record;
559 record_prefix_is (table_entry *entry, char ch, int nr_fields)
561 if (entry->type != table_colon_entry)
563 if (entry->nr_fields < nr_fields)
565 if (entry->field[0][0] != ch && ch != '\0')
571 parse_model_data_record (insn_table *isa,
574 int nr_fields, model_data **list)
576 table_entry *model_record = record;
577 table_entry *code_record = NULL;
578 model_data *new_data;
579 if (record->nr_fields < nr_fields)
580 error (record->line, "Incorrect number of fields\n");
581 record = table_read (file);
582 if (record->type == table_code_entry)
584 code_record = record;
585 record = table_read (file);
587 /* create the new data record */
588 new_data = ZALLOC (model_data);
589 new_data->line = model_record->line;
590 filter_parse (&new_data->flags,
591 model_record->field[record_filter_flags_field]);
592 new_data->entry = model_record;
593 new_data->code = code_record;
594 /* append it if not filtered out */
595 if (!is_filtered_out (options.flags_filter,
596 model_record->field[record_filter_flags_field])
597 && !is_filtered_out (options.model_filter,
598 model_record->field[record_filter_models_field]))
600 while (*list != NULL)
601 list = &(*list)->next;
610 insn_bit_size_option = 1,
611 insn_specifying_widths_option,
622 static const name_map option_map[] = {
623 {"insn-bit-size", insn_bit_size_option},
624 {"insn-specifying-widths", insn_specifying_widths_option},
625 {"hi-bit-nr", hi_bit_nr_option},
626 {"flags-filter", flags_filter_option},
627 {"model-filter", model_filter_option},
628 {"multi-sim", multi_sim_option},
629 {"format-names", format_names_option},
630 {"gen-delayed-branch", gen_delayed_branch},
631 {NULL, unknown_option},
635 parse_include_record (table *file, table_entry *record)
637 /* parse the include record */
638 if (record->nr_fields < nr_include_fields)
639 error (record->line, "Incorrect nr fields for include record\n");
641 if (!is_filtered_out (options.flags_filter,
642 record->field[record_filter_flags_field])
643 && !is_filtered_out (options.model_filter,
644 record->field[record_filter_models_field]))
646 table_push (file, record->line, options.include,
647 record->field[include_filename_field]);
649 /* nb: can't read next record until after the file has been pushed */
650 record = table_read (file);
656 parse_option_record (table *file, table_entry *record)
658 table_entry *option_record;
659 /* parse the option record */
660 option_record = record;
661 if (record->nr_fields < nr_option_fields)
662 error (record->line, "Incorrect nr of fields for option record\n");
663 record = table_read (file);
665 if (!is_filtered_out (options.flags_filter,
666 option_record->field[record_filter_flags_field])
667 && !is_filtered_out (options.model_filter,
668 option_record->field[record_filter_models_field]))
670 char *name = option_record->field[option_name_field];
671 option_names option = name2i (name, option_map);
672 char *value = option_record->field[option_value_field];
675 case insn_bit_size_option:
677 options.insn_bit_size = a2i (value);
678 if (options.insn_bit_size < 0
679 || options.insn_bit_size > max_insn_bit_size)
680 error (option_record->line,
681 "Instruction bit size out of range\n");
682 if (options.hi_bit_nr != options.insn_bit_size - 1
683 && options.hi_bit_nr != 0)
684 error (option_record->line,
685 "insn-bit-size / hi-bit-nr conflict\n");
688 case insn_specifying_widths_option:
690 options.insn_specifying_widths = a2i (value);
693 case hi_bit_nr_option:
695 options.hi_bit_nr = a2i (value);
696 if (options.hi_bit_nr != 0
697 && options.hi_bit_nr != options.insn_bit_size - 1)
698 error (option_record->line,
699 "hi-bit-nr / insn-bit-size conflict\n");
702 case flags_filter_option:
704 filter_parse (&options.flags_filter, value);
707 case model_filter_option:
709 filter_parse (&options.model_filter, value);
712 case multi_sim_option:
714 options.gen.multi_sim = a2i (value);
717 case format_names_option:
719 filter_parse (&options.format_name_filter, value);
722 case gen_delayed_branch:
724 options.gen.delayed_branch = a2i (value);
729 error (option_record->line, "Unknown option - %s\n", name);
739 parse_function_record (table *file,
741 function_entry ** list,
742 function_entry ** list_entry,
743 int is_internal, model_table *model)
745 function_entry *new_function;
746 new_function = ZALLOC (function_entry);
747 new_function->line = record->line;
748 new_function->is_internal = is_internal;
749 /* parse the function header */
750 if (record_is_old (record))
752 if (record->nr_fields < nr_old_function_fields)
753 error (record->line, "Missing fields from (old) function record\n");
754 new_function->type = record->field[old_function_typedef_field];
755 new_function->type = record->field[old_function_typedef_field];
756 if (record->nr_fields > old_function_param_field)
757 new_function->param = record->field[old_function_param_field];
758 new_function->name = record->field[old_function_name_field];
762 if (record->nr_fields < nr_function_fields)
763 error (record->line, "Missing fields from function record\n");
764 filter_parse (&new_function->flags,
765 record->field[record_filter_flags_field]);
766 filter_parse (&new_function->models,
767 record->field[record_filter_models_field]);
768 new_function->type = record->field[function_typedef_field];
769 new_function->param = record->field[function_param_field];
770 new_function->name = record->field[function_name_field];
772 record = table_read (file);
773 /* parse any function-model records */
774 while (record != NULL
775 && record_prefix_is (record, '*', nr_function_model_fields))
777 char *model_name = record->field[function_model_name_field] + 1; /*skip `*' */
778 filter_parse (&new_function->models, model_name);
779 if (!filter_is_subset (model->processors, new_function->models))
781 error (record->line, "machine model `%s' undefined\n", model_name);
783 record = table_read (file);
785 /* parse the function body */
786 if (record->type == table_code_entry)
788 new_function->code = record;
789 record = table_read (file);
792 if (!filter_is_subset (options.flags_filter, new_function->flags))
794 if (options.warn.discard)
795 notify (new_function->line, "Discarding function %s - filter flags\n",
798 else if (new_function->models != NULL
799 && !filter_is_common (options.model_filter, new_function->models))
801 if (options.warn.discard)
802 notify (new_function->line,
803 "Discarding function %s - filter models\n",
808 while (*list != NULL)
809 list = &(*list)->next;
810 *list = new_function;
811 if (list_entry != NULL)
812 *list_entry = new_function;
819 parse_insn_model_record (table *file,
821 insn_entry * insn, model_table *model)
823 insn_model_entry **last_insn_model;
824 insn_model_entry *new_insn_model = ZALLOC (insn_model_entry);
826 new_insn_model->line = record->line;
827 if (record->nr_fields > insn_model_unit_data_field)
828 new_insn_model->unit_data = record->field[insn_model_unit_data_field];
829 new_insn_model->insn = insn;
830 /* parse the model names, verify that all were defined */
831 new_insn_model->names = NULL;
832 filter_parse (&new_insn_model->names,
833 record->field[insn_model_name_field] + 1 /*skip `*' */ );
834 if (new_insn_model->names == NULL)
836 /* No processor names - a generic model entry, enter it into all
837 the non-empty fields */
839 for (index = 0; index < model->nr_models; index++)
840 if (insn->model[index] == 0)
842 insn->model[index] = new_insn_model;
844 /* also add the complete processor set to this processor's set */
845 filter_add (&insn->processors, model->processors);
849 /* Find the corresponding master model record for each name so
850 that they can be linked in. */
855 name = filter_next (new_insn_model->names, name);
858 index = filter_is_member (model->processors, name) - 1;
861 error (new_insn_model->line,
862 "machine model `%s' undefined\n", name);
864 /* store it in the corresponding model array entry */
865 if (insn->model[index] != NULL && insn->model[index]->names != NULL)
867 warning (new_insn_model->line,
868 "machine model `%s' previously defined\n", name);
869 error (insn->model[index]->line, "earlier definition\n");
871 insn->model[index] = new_insn_model;
872 /* also add the name to the instructions processor set as an
873 alternative lookup mechanism */
874 filter_parse (&insn->processors, name);
878 last_insn_model = &insn->models;
879 while ((*last_insn_model) != NULL)
880 last_insn_model = &(*last_insn_model)->next;
881 *last_insn_model = new_insn_model;
886 parse_insn_mnemonic_record (table *file,
887 table_entry *record, insn_entry * insn)
889 insn_mnemonic_entry **last_insn_mnemonic;
890 insn_mnemonic_entry *new_insn_mnemonic = ZALLOC (insn_mnemonic_entry);
892 new_insn_mnemonic->line = record->line;
893 ASSERT (record->nr_fields > insn_mnemonic_format_field);
894 new_insn_mnemonic->format = record->field[insn_mnemonic_format_field];
895 ASSERT (new_insn_mnemonic->format[0] == '"');
896 if (new_insn_mnemonic->format[strlen (new_insn_mnemonic->format) - 1] !=
898 error (new_insn_mnemonic->line,
899 "Missing closing double quote in mnemonic field\n");
900 if (record->nr_fields > insn_mnemonic_condition_field)
901 new_insn_mnemonic->condition =
902 record->field[insn_mnemonic_condition_field];
903 new_insn_mnemonic->insn = insn;
905 last_insn_mnemonic = &insn->mnemonics;
906 while ((*last_insn_mnemonic) != NULL)
907 last_insn_mnemonic = &(*last_insn_mnemonic)->next;
908 insn->nr_mnemonics++;
909 *last_insn_mnemonic = new_insn_mnemonic;
914 parse_macro_record (table *file, table_entry *record)
917 error (record->line, "Macros are not implemented");
919 /* parse the define record */
920 if (record->nr_fields < nr_define_fields)
921 error (record->line, "Incorrect nr fields for define record\n");
923 if (!is_filtered_out (options.flags_filter,
924 record->field[record_filter_flags_field])
925 && !is_filtered_out (options.model_filter,
926 record->field[record_filter_models_field]))
930 record->field[macro_name_field],
931 record->field[macro_args_field],
932 record->field[macro_expr_field]);
934 record = table_read (file);
941 load_insn_table (char *file_name, cache_entry *cache)
943 table *file = table_open (file_name);
944 table_entry *record = table_read (file);
946 insn_table *isa = ZALLOC (insn_table);
947 model_table *model = ZALLOC (model_table);
952 while (record != NULL)
955 switch (record_type (record))
960 record = parse_include_record (file, record);
966 if (isa->insns != NULL)
967 error (record->line, "Option after first instruction\n");
968 record = parse_option_record (file, record);
972 case string_function_record:
974 function_entry *function = NULL;
975 record = parse_function_record (file, record,
977 &function, 0 /*is-internal */ ,
979 /* convert a string function record into an internal function */
980 if (function != NULL)
982 char *name = NZALLOC (char,
984 + strlen (function->name) + 1));
985 strcat (name, "str_");
986 strcat (name, function->name);
987 function->name = name;
988 function->type = "const char *";
993 case function_record: /* function record */
995 record = parse_function_record (file, record,
997 NULL, 0 /*is-internal */ ,
1002 case internal_record:
1004 /* only insert it into the function list if it is unknown */
1005 function_entry *function = NULL;
1006 record = parse_function_record (file, record,
1008 &function, 1 /*is-internal */ ,
1010 /* check what was inserted to see if a pseudo-instruction
1011 entry also needs to be created */
1012 if (function != NULL)
1014 insn_entry **insn = NULL;
1015 if (strcmp (function->name, "illegal") == 0)
1017 /* illegal function save it away */
1018 if (isa->illegal_insn != NULL)
1020 warning (function->line,
1021 "Multiple illegal instruction definitions\n");
1022 error (isa->illegal_insn->line,
1023 "Location of first illegal instruction\n");
1026 insn = &isa->illegal_insn;
1030 *insn = ZALLOC (insn_entry);
1031 (*insn)->line = function->line;
1032 (*insn)->name = function->name;
1033 (*insn)->code = function->code;
1039 case scratch_record: /* cache macro records */
1041 case compute_record:
1043 cache_entry *new_cache;
1044 /* parse the cache record */
1045 if (record->nr_fields < nr_cache_fields)
1046 error (record->line,
1047 "Incorrect nr of fields for scratch/cache/compute record\n");
1049 new_cache = ZALLOC (cache_entry);
1050 new_cache->line = record->line;
1051 filter_parse (&new_cache->flags,
1052 record->field[record_filter_flags_field]);
1053 filter_parse (&new_cache->models,
1054 record->field[record_filter_models_field]);
1055 new_cache->type = record->field[cache_typedef_field];
1056 new_cache->name = record->field[cache_name_field];
1057 filter_parse (&new_cache->original_fields,
1058 record->field[cache_original_fields_field]);
1059 new_cache->expression = record->field[cache_expression_field];
1060 /* insert it but only if not filtered out */
1061 if (!filter_is_subset (options.flags_filter, new_cache->flags))
1063 notify (new_cache->line,
1064 "Discarding cache entry %s - filter flags\n",
1067 else if (is_filtered_out (options.model_filter,
1069 field[record_filter_models_field]))
1071 notify (new_cache->line,
1072 "Discarding cache entry %s - filter models\n",
1078 last = &isa->caches;
1079 while (*last != NULL)
1080 last = &(*last)->next;
1083 /* advance things */
1084 record = table_read (file);
1089 case model_processor_record:
1091 model_entry *new_model;
1092 /* parse the model */
1093 if (record->nr_fields < nr_model_processor_fields)
1094 error (record->line,
1095 "Incorrect nr of fields for model record\n");
1096 if (isa->insns != NULL)
1097 error (record->line, "Model appears after first instruction\n");
1098 new_model = ZALLOC (model_entry);
1099 filter_parse (&new_model->flags,
1100 record->field[record_filter_flags_field]);
1101 new_model->line = record->line;
1102 new_model->name = record->field[model_name_field];
1103 new_model->full_name = record->field[model_full_name_field];
1104 new_model->unit_data = record->field[model_unit_data_field];
1105 /* only insert it if not filtered out */
1106 if (!filter_is_subset (options.flags_filter, new_model->flags))
1108 notify (new_model->line,
1109 "Discarding processor model %s - filter flags\n",
1112 else if (is_filtered_out (options.model_filter,
1114 field[record_filter_models_field]))
1116 notify (new_model->line,
1117 "Discarding processor model %s - filter models\n",
1120 else if (filter_is_member (model->processors, new_model->name))
1122 error (new_model->line, "Duplicate processor model %s\n",
1128 last = &model->models;
1129 while (*last != NULL)
1130 last = &(*last)->next;
1134 filter_parse (&model->processors, new_model->name);
1136 /* advance things */
1137 record = table_read (file);
1141 case model_macro_record:
1142 record = parse_model_data_record (isa, file, record,
1143 nr_model_macro_fields,
1147 case model_data_record:
1148 record = parse_model_data_record (isa, file, record,
1149 nr_model_data_fields,
1153 case model_static_record:
1154 record = parse_function_record (file, record,
1156 NULL, 0 /*is internal */ ,
1160 case model_internal_record:
1161 record = parse_function_record (file, record,
1163 NULL, 1 /*is internal */ ,
1167 case model_function_record:
1168 record = parse_function_record (file, record,
1170 NULL, 0 /*is internal */ ,
1174 case insn_record: /* instruction records */
1176 insn_entry *new_insn;
1178 /* parse the instruction */
1179 if (record->nr_fields < nr_insn_fields)
1180 error (record->line,
1181 "Incorrect nr of fields for insn record\n");
1182 new_insn = ZALLOC (insn_entry);
1183 new_insn->line = record->line;
1184 filter_parse (&new_insn->flags,
1185 record->field[record_filter_flags_field]);
1186 /* save the format field. Can't parse it until after the
1187 filter-out checks. Could be filtered out because the
1188 format is invalid */
1189 format = record->field[insn_word_field];
1190 new_insn->format_name = record->field[insn_format_name_field];
1191 if (options.format_name_filter != NULL
1192 && !filter_is_member (options.format_name_filter,
1193 new_insn->format_name))
1194 error (new_insn->line,
1195 "Unreconized instruction format name `%s'\n",
1196 new_insn->format_name);
1197 filter_parse (&new_insn->options,
1198 record->field[insn_options_field]);
1199 new_insn->name = record->field[insn_name_field];
1200 record = table_read (file);
1201 /* Parse any model/assember records */
1202 new_insn->nr_models = model->nr_models;
1204 NZALLOC (insn_model_entry *, model->nr_models + 1);
1205 while (record != NULL)
1207 if (record_prefix_is (record, '*', nr_insn_model_fields))
1208 parse_insn_model_record (file, record, new_insn, model);
1210 if (record_prefix_is (record, '"', nr_insn_mnemonic_fields))
1211 parse_insn_mnemonic_record (file, record, new_insn);
1215 record = table_read (file);
1217 /* Parse the code record */
1218 if (record != NULL && record->type == table_code_entry)
1220 new_insn->code = record;
1221 record = table_read (file);
1223 else if (options.warn.unimplemented)
1224 notify (new_insn->line, "unimplemented\n");
1226 if (!filter_is_subset (options.flags_filter, new_insn->flags))
1228 if (options.warn.discard)
1229 notify (new_insn->line,
1230 "Discarding instruction %s (flags-filter)\n",
1233 else if (new_insn->processors != NULL
1234 && options.model_filter != NULL
1235 && !filter_is_common (options.model_filter,
1236 new_insn->processors))
1238 /* only discard an instruction based in the processor
1239 model when both the instruction and the options are
1241 if (options.warn.discard)
1242 notify (new_insn->line,
1243 "Discarding instruction %s (processor-model)\n",
1249 /* finish the parsing */
1250 parse_insn_words (new_insn, format);
1254 last = &(*last)->next;
1256 /* update global isa counters */
1258 if (isa->max_nr_words < new_insn->nr_words)
1259 isa->max_nr_words = new_insn->nr_words;
1260 filter_add (&isa->flags, new_insn->flags);
1261 filter_add (&isa->options, new_insn->options);
1267 record = parse_macro_record (file, record);
1270 case unknown_record:
1272 error (record->line, "Unknown or unexpected entry\n");
1282 print_insn_words (lf *file, insn_entry * insn)
1284 insn_word_entry *word = insn->words;
1289 insn_field_entry *field = word->first;
1292 if (options.insn_specifying_widths)
1293 lf_printf (file, "%d.", field->width);
1295 lf_printf (file, "%d.",
1296 i2target (options.hi_bit_nr, field->first));
1297 switch (field->type)
1299 case insn_field_invalid:
1302 case insn_field_int:
1303 lf_printf (file, "0x%lx", (long) field->val_int);
1305 case insn_field_reserved:
1306 lf_printf (file, "/");
1308 case insn_field_wild:
1309 lf_printf (file, "*");
1311 case insn_field_string:
1312 lf_printf (file, "%s", field->val_string);
1315 if (field == word->last)
1317 field = field->next;
1318 lf_printf (file, ",");
1323 lf_printf (file, "+");
1331 function_entry_traverse (lf *file,
1332 function_entry * functions,
1333 function_entry_handler * handler, void *data)
1335 function_entry *function;
1336 for (function = functions; function != NULL; function = function->next)
1338 handler (file, function, data);
1343 insn_table_traverse_insn (lf *file,
1345 insn_entry_handler * handler, void *data)
1348 for (insn = isa->insns; insn != NULL; insn = insn->next)
1350 handler (file, isa, insn, data);
1356 dump_function_entry (lf *file,
1357 char *prefix, function_entry * entry, char *suffix)
1359 lf_printf (file, "%s(function_entry *) 0x%lx", prefix, (long) entry);
1362 dump_line_ref (file, "\n(line ", entry->line, ")");
1363 dump_filter (file, "\n(flags ", entry->flags, ")");
1364 lf_printf (file, "\n(type \"%s\")", entry->type);
1365 lf_printf (file, "\n(name \"%s\")", entry->name);
1366 lf_printf (file, "\n(param \"%s\")", entry->param);
1367 dump_table_entry (file, "\n(code ", entry->code, ")");
1368 lf_printf (file, "\n(is_internal %d)", entry->is_internal);
1369 lf_printf (file, "\n(next 0x%lx)", (long) entry->next);
1371 lf_printf (file, "%s", suffix);
1375 dump_function_entries (lf *file,
1376 char *prefix, function_entry * entry, char *suffix)
1378 lf_printf (file, "%s", prefix);
1379 lf_indent (file, +1);
1380 while (entry != NULL)
1382 dump_function_entry (file, "\n(", entry, ")");
1383 entry = entry->next;
1385 lf_indent (file, -1);
1386 lf_printf (file, "%s", suffix);
1390 cache_entry_type_to_str (cache_entry_type type)
1401 ERROR ("Bad switch");
1406 dump_cache_entry (lf *file, char *prefix, cache_entry *entry, char *suffix)
1408 lf_printf (file, "%s(cache_entry *) 0x%lx", prefix, (long) entry);
1411 dump_line_ref (file, "\n(line ", entry->line, ")");
1412 dump_filter (file, "\n(flags ", entry->flags, ")");
1413 lf_printf (file, "\n(entry_type \"%s\")",
1414 cache_entry_type_to_str (entry->entry_type));
1415 lf_printf (file, "\n(name \"%s\")", entry->name);
1416 dump_filter (file, "\n(original_fields ", entry->original_fields, ")");
1417 lf_printf (file, "\n(type \"%s\")", entry->type);
1418 lf_printf (file, "\n(expression \"%s\")", entry->expression);
1419 lf_printf (file, "\n(next 0x%lx)", (long) entry->next);
1421 lf_printf (file, "%s", suffix);
1425 dump_cache_entries (lf *file, char *prefix, cache_entry *entry, char *suffix)
1427 lf_printf (file, "%s", prefix);
1428 lf_indent (file, +1);
1429 while (entry != NULL)
1431 dump_cache_entry (file, "\n(", entry, ")");
1432 entry = entry->next;
1434 lf_indent (file, -1);
1435 lf_printf (file, "%s", suffix);
1439 dump_model_data (lf *file, char *prefix, model_data *entry, char *suffix)
1441 lf_printf (file, "%s(model_data *) 0x%lx", prefix, (long) entry);
1444 lf_indent (file, +1);
1445 dump_line_ref (file, "\n(line ", entry->line, ")");
1446 dump_filter (file, "\n(flags ", entry->flags, ")");
1447 dump_table_entry (file, "\n(entry ", entry->entry, ")");
1448 dump_table_entry (file, "\n(code ", entry->code, ")");
1449 lf_printf (file, "\n(next 0x%lx)", (long) entry->next);
1450 lf_indent (file, -1);
1452 lf_printf (file, "%s", prefix);
1456 dump_model_datas (lf *file, char *prefix, model_data *entry, char *suffix)
1458 lf_printf (file, "%s", prefix);
1459 lf_indent (file, +1);
1460 while (entry != NULL)
1462 dump_model_data (file, "\n(", entry, ")");
1463 entry = entry->next;
1465 lf_indent (file, -1);
1466 lf_printf (file, "%s", suffix);
1470 dump_model_entry (lf *file, char *prefix, model_entry *entry, char *suffix)
1472 lf_printf (file, "%s(model_entry *) 0x%lx", prefix, (long) entry);
1475 lf_indent (file, +1);
1476 dump_line_ref (file, "\n(line ", entry->line, ")");
1477 dump_filter (file, "\n(flags ", entry->flags, ")");
1478 lf_printf (file, "\n(name \"%s\")", entry->name);
1479 lf_printf (file, "\n(full_name \"%s\")", entry->full_name);
1480 lf_printf (file, "\n(unit_data \"%s\")", entry->unit_data);
1481 lf_printf (file, "\n(next 0x%lx)", (long) entry->next);
1482 lf_indent (file, -1);
1484 lf_printf (file, "%s", prefix);
1488 dump_model_entries (lf *file, char *prefix, model_entry *entry, char *suffix)
1490 lf_printf (file, "%s", prefix);
1491 lf_indent (file, +1);
1492 while (entry != NULL)
1494 dump_model_entry (file, "\n(", entry, ")");
1495 entry = entry->next;
1497 lf_indent (file, -1);
1498 lf_printf (file, "%s", suffix);
1503 dump_model_table (lf *file, char *prefix, model_table *entry, char *suffix)
1505 lf_printf (file, "%s(model_table *) 0x%lx", prefix, (long) entry);
1508 lf_indent (file, +1);
1509 dump_filter (file, "\n(processors ", entry->processors, ")");
1510 lf_printf (file, "\n(nr_models %d)", entry->nr_models);
1511 dump_model_entries (file, "\n(models ", entry->models, ")");
1512 dump_model_datas (file, "\n(macros ", entry->macros, ")");
1513 dump_model_datas (file, "\n(data ", entry->data, ")");
1514 dump_function_entries (file, "\n(statics ", entry->statics, ")");
1515 dump_function_entries (file, "\n(internals ", entry->functions, ")");
1516 dump_function_entries (file, "\n(functions ", entry->functions, ")");
1517 lf_indent (file, -1);
1519 lf_printf (file, "%s", suffix);
1524 insn_field_type_to_str (insn_field_type type)
1528 case insn_field_invalid:
1531 case insn_field_int:
1533 case insn_field_reserved:
1535 case insn_field_wild:
1537 case insn_field_string:
1540 ERROR ("bad switch");
1545 dump_insn_field (lf *file,
1546 char *prefix, insn_field_entry *field, char *suffix)
1549 lf_printf (file, "%s(insn_field_entry *) 0x%lx", prefix, (long) field);
1552 lf_indent (file, +1);
1553 lf_printf (file, "%s(first %d)", sep, field->first);
1554 lf_printf (file, "%s(last %d)", sep, field->last);
1555 lf_printf (file, "%s(width %d)", sep, field->width);
1556 lf_printf (file, "%s(type %s)", sep,
1557 insn_field_type_to_str (field->type));
1558 switch (field->type)
1560 case insn_field_invalid:
1563 case insn_field_int:
1564 lf_printf (file, "%s(val 0x%lx)", sep, (long) field->val_int);
1566 case insn_field_reserved:
1567 /* nothing output */
1569 case insn_field_wild:
1570 /* nothing output */
1572 case insn_field_string:
1573 lf_printf (file, "%s(val \"%s\")", sep, field->val_string);
1576 lf_printf (file, "%s(next 0x%lx)", sep, (long) field->next);
1577 lf_printf (file, "%s(prev 0x%lx)", sep, (long) field->prev);
1578 lf_indent (file, -1);
1580 lf_printf (file, "%s", suffix);
1584 dump_insn_word_entry (lf *file,
1585 char *prefix, insn_word_entry *word, char *suffix)
1587 lf_printf (file, "%s(insn_word_entry *) 0x%lx", prefix, (long) word);
1591 insn_field_entry *field;
1592 lf_indent (file, +1);
1593 lf_printf (file, "\n(first 0x%lx)", (long) word->first);
1594 lf_printf (file, "\n(last 0x%lx)", (long) word->last);
1595 lf_printf (file, "\n(bit");
1596 for (i = 0; i < options.insn_bit_size; i++)
1597 lf_printf (file, "\n ((value %d) (mask %d) (field 0x%lx))",
1598 word->bit[i]->value, word->bit[i]->mask,
1599 (long) word->bit[i]->field);
1600 lf_printf (file, ")");
1601 for (field = word->first; field != NULL; field = field->next)
1602 dump_insn_field (file, "\n(", field, ")");
1603 dump_filter (file, "\n(field_names ", word->field_names, ")");
1604 lf_printf (file, "\n(next 0x%lx)", (long) word->next);
1605 lf_indent (file, -1);
1607 lf_printf (file, "%s", suffix);
1611 dump_insn_word_entries (lf *file,
1612 char *prefix, insn_word_entry *word, char *suffix)
1614 lf_printf (file, "%s", prefix);
1615 while (word != NULL)
1617 dump_insn_word_entry (file, "\n(", word, ")");
1620 lf_printf (file, "%s", suffix);
1624 dump_insn_model_entry (lf *file,
1625 char *prefix, insn_model_entry *model, char *suffix)
1627 lf_printf (file, "%s(insn_model_entry *) 0x%lx", prefix, (long) model);
1630 lf_indent (file, +1);
1631 dump_line_ref (file, "\n(line ", model->line, ")");
1632 dump_filter (file, "\n(names ", model->names, ")");
1633 lf_printf (file, "\n(full_name \"%s\")", model->full_name);
1634 lf_printf (file, "\n(unit_data \"%s\")", model->unit_data);
1635 lf_printf (file, "\n(insn (insn_entry *) 0x%lx)", (long) model->insn);
1636 lf_printf (file, "\n(next (insn_model_entry *) 0x%lx)",
1637 (long) model->next);
1638 lf_indent (file, -1);
1640 lf_printf (file, "%s", suffix);
1644 dump_insn_model_entries (lf *file,
1645 char *prefix, insn_model_entry *model, char *suffix)
1647 lf_printf (file, "%s", prefix);
1648 while (model != NULL)
1650 dump_insn_model_entry (file, "\n", model, "");
1651 model = model->next;
1653 lf_printf (file, "%s", suffix);
1658 dump_insn_mnemonic_entry (lf *file,
1660 insn_mnemonic_entry *mnemonic, char *suffix)
1662 lf_printf (file, "%s(insn_mnemonic_entry *) 0x%lx", prefix,
1664 if (mnemonic != NULL)
1666 lf_indent (file, +1);
1667 dump_line_ref (file, "\n(line ", mnemonic->line, ")");
1668 lf_printf (file, "\n(format \"%s\")", mnemonic->format);
1669 lf_printf (file, "\n(condition \"%s\")", mnemonic->condition);
1670 lf_printf (file, "\n(insn (insn_entry *) 0x%lx)",
1671 (long) mnemonic->insn);
1672 lf_printf (file, "\n(next (insn_mnemonic_entry *) 0x%lx)",
1673 (long) mnemonic->next);
1674 lf_indent (file, -1);
1676 lf_printf (file, "%s", suffix);
1680 dump_insn_mnemonic_entries (lf *file,
1682 insn_mnemonic_entry *mnemonic, char *suffix)
1684 lf_printf (file, "%s", prefix);
1685 while (mnemonic != NULL)
1687 dump_insn_mnemonic_entry (file, "\n", mnemonic, "");
1688 mnemonic = mnemonic->next;
1690 lf_printf (file, "%s", suffix);
1694 dump_insn_entry (lf *file, char *prefix, insn_entry * entry, char *suffix)
1696 lf_printf (file, "%s(insn_entry *) 0x%lx", prefix, (long) entry);
1700 lf_indent (file, +1);
1701 dump_line_ref (file, "\n(line ", entry->line, ")");
1702 dump_filter (file, "\n(flags ", entry->flags, ")");
1703 lf_printf (file, "\n(nr_words %d)", entry->nr_words);
1704 dump_insn_word_entries (file, "\n(words ", entry->words, ")");
1705 lf_printf (file, "\n(word");
1706 for (i = 0; i < entry->nr_models; i++)
1707 lf_printf (file, " 0x%lx", (long) entry->word[i]);
1708 lf_printf (file, ")");
1709 dump_filter (file, "\n(field_names ", entry->field_names, ")");
1710 lf_printf (file, "\n(format_name \"%s\")", entry->format_name);
1711 dump_filter (file, "\n(options ", entry->options, ")");
1712 lf_printf (file, "\n(name \"%s\")", entry->name);
1713 lf_printf (file, "\n(nr_models %d)", entry->nr_models);
1714 dump_insn_model_entries (file, "\n(models ", entry->models, ")");
1715 lf_printf (file, "\n(model");
1716 for (i = 0; i < entry->nr_models; i++)
1717 lf_printf (file, " 0x%lx", (long) entry->model[i]);
1718 lf_printf (file, ")");
1719 dump_filter (file, "\n(processors ", entry->processors, ")");
1720 dump_insn_mnemonic_entries (file, "\n(mnemonics ", entry->mnemonics,
1722 dump_table_entry (file, "\n(code ", entry->code, ")");
1723 lf_printf (file, "\n(next 0x%lx)", (long) entry->next);
1724 lf_indent (file, -1);
1726 lf_printf (file, "%s", suffix);
1730 dump_insn_entries (lf *file, char *prefix, insn_entry * entry, char *suffix)
1732 lf_printf (file, "%s", prefix);
1733 lf_indent (file, +1);
1734 while (entry != NULL)
1736 dump_insn_entry (file, "\n(", entry, ")");
1737 entry = entry->next;
1739 lf_indent (file, -1);
1740 lf_printf (file, "%s", suffix);
1746 dump_insn_table (lf *file, char *prefix, insn_table *isa, char *suffix)
1748 lf_printf (file, "%s(insn_table *) 0x%lx", prefix, (long) isa);
1751 lf_indent (file, +1);
1752 dump_cache_entries (file, "\n(caches ", isa->caches, ")");
1753 lf_printf (file, "\n(nr_insns %d)", isa->nr_insns);
1754 lf_printf (file, "\n(max_nr_words %d)", isa->max_nr_words);
1755 dump_insn_entries (file, "\n(insns ", isa->insns, ")");
1756 dump_function_entries (file, "\n(functions ", isa->functions, ")");
1757 dump_insn_entry (file, "\n(illegal_insn ", isa->illegal_insn, ")");
1758 dump_model_table (file, "\n(model ", isa->model, ")");
1759 dump_filter (file, "\n(flags ", isa->flags, ")");
1760 dump_filter (file, "\n(options ", isa->options, ")");
1761 lf_indent (file, -1);
1763 lf_printf (file, "%s", suffix);
1768 igen_options options;
1771 main (int argc, char **argv)
1776 INIT_OPTIONS (options);
1779 filter_parse (&options.flags_filter, argv[2]);
1781 error (NULL, "Usage: insn <insn-table> [ <filter-in> ]\n");
1783 isa = load_insn_table (argv[1], NULL);
1784 l = lf_open ("-", "stdout", lf_omit_references, lf_is_text, "tmp-ld-insn");
1785 dump_insn_table (l, "(isa ", isa, ")\n");