1 /* This file is part of the program psim.
3 Copyright (C) 1994-1997, 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.
29 static insn_word_entry
*
30 parse_insn_word (line_ref
*line
,
35 insn_word_entry
*word
= ZALLOC (insn_word_entry
);
37 /* create a leading sentinal */
38 word
->first
= ZALLOC (insn_field_entry
);
39 word
->first
->first
= -1;
40 word
->first
->last
= -1;
41 word
->first
->width
= 0;
43 /* and a trailing sentinal */
44 word
->last
= ZALLOC (insn_field_entry
);
45 word
->last
->first
= options
.insn_bit_size
;
46 word
->last
->last
= options
.insn_bit_size
;
47 word
->last
->width
= 0;
49 /* link them together */
50 word
->first
->next
= word
->last
;
51 word
->last
->prev
= word
->first
;
53 /* now work through the formats */
54 chp
= skip_spaces (string
);
56 while (*chp
!= '\0') {
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
))
113 while (isalnum(*chp
));
115 strlen_val
= chp
- start_val
;
116 chp
= skip_spaces (chp
);
119 error (line
, "Empty value field\n");
121 /* break out any conditional fields - { "!" <value> } */
126 insn_field_exclusion
*new_exclusion
= ZALLOC (insn_field_exclusion
);
127 insn_field_exclusion
**last
;
129 /* what type of conditional field */
131 chp
= skip_spaces (chp
);
134 chp
= skip_digits (chp
);
137 error (line
, "Missing or invalid conditional value\n");
138 /* fill in the entry */
139 new_exclusion
->string
= NZALLOC (char, len
+ 1);
140 strncpy (new_exclusion
->string
, start
, len
);
141 new_exclusion
->value
= a2i (new_exclusion
->string
);
143 last
= &new_field
->exclusions
;
144 while (*last
!= NULL
)
145 last
= &(*last
)->next
;
146 *last
= new_exclusion
;
147 chp
= skip_spaces (chp
);
150 /* NOW verify that the field ws finished */
153 chp
= skip_spaces (chp
+ 1);
155 error (line
, "empty field\n");
157 else if (*chp
!= '\0')
159 error (line
, "Missing field separator");
163 new_field
->val_string
= NZALLOC (char, strlen_val
+1);
164 strncpy (new_field
->val_string
, start_val
, strlen_val
);
165 if (isdigit (new_field
->val_string
[0]))
169 /* when the length/pos field is omited, an integer field
173 for (i
= 0; i
< strlen_val
; i
++)
175 if (new_field
->val_string
[i
] != '0'
176 && new_field
->val_string
[i
] != '1')
177 error (line
, "invalid binary field %s\n",
178 new_field
->val_string
);
179 val
= (val
<< 1) + (new_field
->val_string
[i
] == '1');
181 new_field
->val_int
= val
;
182 new_field
->type
= insn_field_int
;
186 new_field
->val_int
= a2i (new_field
->val_string
);
187 new_field
->type
= insn_field_int
;
190 else if (new_field
->val_string
[0] == '/')
192 new_field
->type
= insn_field_reserved
;
194 else if (new_field
->val_string
[0] == '*')
196 new_field
->type
= insn_field_wild
;
200 new_field
->type
= insn_field_string
;
201 if (filter_is_member (word
->field_names
, new_field
->val_string
))
202 error (line
, "Field name %s is duplicated\n", new_field
->val_string
);
203 filter_parse (&word
->field_names
, new_field
->val_string
);
205 if (new_field
->type
!= insn_field_string
206 && new_field
->exclusions
!= NULL
)
207 error (line
, "Exclusions only apply to name fields\n");
209 /* the copy the position */
210 new_field
->pos_string
= NZALLOC (char, strlen_pos
+ 1);
211 strncpy (new_field
->pos_string
, start_pos
, strlen_pos
);
214 new_field
->first
= new_field
->prev
->last
+ 1;
215 if (new_field
->first
== 0 /* first field */
216 && *chp
== '\0' /* no further fields */
217 && new_field
->type
== insn_field_string
)
219 /* A single string without any position, assume that it
220 represents the entire instruction word */
221 new_field
->width
= options
.insn_bit_size
;
225 /* No explicit width/position, assume value implicitly
226 supplies the width */
227 new_field
->width
= strlen_val
;
229 new_field
->last
= new_field
->first
+ new_field
->width
- 1;
230 if (new_field
->last
>= options
.insn_bit_size
)
231 error (line
, "Bit position %d exceed instruction bit size (%d)\n",
232 new_field
->last
, options
.insn_bit_size
);
234 else if (options
.insn_specifying_widths
)
236 new_field
->first
= new_field
->prev
->last
+ 1;
237 new_field
->width
= a2i(new_field
->pos_string
);
238 new_field
->last
= new_field
->first
+ new_field
->width
- 1;
239 if (new_field
->last
>= options
.insn_bit_size
)
240 error (line
, "Bit position %d exceed instruction bit size (%d)\n",
241 new_field
->last
, options
.insn_bit_size
);
245 new_field
->first
= target_a2i(options
.hi_bit_nr
,
246 new_field
->pos_string
);
247 new_field
->last
= new_field
->next
->first
- 1; /* guess */
248 new_field
->width
= new_field
->last
- new_field
->first
+ 1; /* guess */
249 new_field
->prev
->last
= new_field
->first
- 1; /*fix*/
250 new_field
->prev
->width
= new_field
->first
- new_field
->prev
->first
; /*fix*/
254 /* fiddle first/last so that the sentinals disapear */
255 ASSERT(word
->first
->last
< 0);
256 ASSERT(word
->last
->first
>= options
.insn_bit_size
);
257 word
->first
= word
->first
->next
;
258 word
->last
= word
->last
->prev
;
260 /* check that the last field goes all the way to the last bit */
261 if (word
->last
->last
!= options
.insn_bit_size
- 1)
263 options
.warning (line
, "Instruction format is not %d bits wide\n",
264 options
.insn_bit_size
);
265 word
->last
->last
= options
.insn_bit_size
- 1;
268 /* now go over this again, pointing each bit position at a field
271 insn_field_entry
*field
;
272 for (field
= word
->first
;
273 field
->last
< options
.insn_bit_size
;
277 for (i
= field
->first
; i
<= field
->last
; i
++)
279 word
->bit
[i
] = ZALLOC (insn_bit_entry
);
280 word
->bit
[i
]->field
= field
;
284 word
->bit
[i
]->mask
= 1;
285 word
->bit
[i
]->value
= ((field
->val_int
286 & ((insn_uint
)1 << (field
->last
- i
)))
288 case insn_field_reserved
:
289 case insn_field_wild
:
290 case insn_field_string
:
302 parse_insn_words (insn_entry
*insn
,
305 insn_word_entry
**last_word
= &insn
->words
;
308 /* now work through the formats */
318 insn_word_entry
*new_word
;
320 /* skip leading spaces */
321 chp
= skip_spaces (chp
);
323 /* break out the format */
325 chp
= skip_to_separator (chp
, "+");
326 end_pos
= back_spaces (start_pos
, chp
);
327 strlen_pos
= end_pos
- start_pos
;
329 /* check that something was there */
331 error (insn
->line
, "missing or empty instruction format\n");
333 /* parse the field */
334 format
= NZALLOC (char, strlen_pos
+ 1);
335 strncpy (format
, start_pos
, strlen_pos
);
336 new_word
= parse_insn_word (insn
->line
, format
, insn
->nr_words
);
338 if (filter_is_common (insn
->field_names
, new_word
->field_names
))
339 error (insn
->line
, "Field name duplicated between two words\n");
340 filter_add (&insn
->field_names
, new_word
->field_names
);
343 *last_word
= new_word
;
344 last_word
= &new_word
->next
;
349 ASSERT (*chp
== '+');
353 /* now create a quick access array of the same structure */
356 insn_word_entry
*word
;
357 insn
->word
= NZALLOC (insn_word_entry
*, insn
->nr_words
+ 1);
358 for (i
= 0, word
= insn
->words
;
360 i
++, word
= word
->next
)
361 insn
->word
[i
] = word
;
367 insn_record
, /* default */
373 string_function_record
,
377 model_processor_record
,
381 model_function_record
,
382 model_internal_record
,
385 static const name_map insn_type_map
[] = {
386 { "option", option_record
},
387 { "cache", cache_record
},
388 { "compute", compute_record
},
389 { "scratch", scratch_record
},
390 { "define", define_record
},
391 { "%s", string_function_record
},
392 { "function", function_record
},
393 { "internal", internal_record
},
394 { "model", model_processor_record
},
395 { "model-macro", model_macro_record
},
396 { "model-data", model_data_record
},
397 { "model-static", model_static_record
},
398 { "model-internal", model_internal_record
},
399 { "model-function", model_function_record
},
400 { NULL
, insn_record
},
405 record_is_old (table_entry
*entry
)
407 if (entry
->nr_fields
> record_type_field
408 && strlen (entry
->field
[record_type_field
]) == 0)
413 static insn_record_type
414 record_type (table_entry
*entry
)
418 case table_code_entry
:
421 case table_colon_entry
:
422 if (record_is_old (entry
))
425 if (entry
->nr_fields
> old_record_type_field
)
427 int i
= name2i (entry
->field
[old_record_type_field
],
433 return unknown_record
;
436 else if (entry
->nr_fields
> record_type_field
437 && entry
->field
[0][0] == '\0')
440 int i
= name2i (entry
->field
[record_type_field
],
445 return insn_record
; /* default */
447 return unknown_record
;
451 record_prefix_is (table_entry
*entry
,
455 if (entry
->type
!= table_colon_entry
)
457 if (entry
->nr_fields
< nr_fields
)
459 if (entry
->field
[0][0] != ch
&& ch
!= '\0')
465 parse_model_data_record (insn_table
*isa
,
471 table_entry
*model_record
= record
;
472 table_entry
*code_record
= NULL
;
473 model_data
*new_data
;
474 if (record
->nr_fields
< nr_fields
)
475 error (record
->line
, "Incorrect number of fields\n");
476 record
= table_read (file
);
477 if (record
->type
== table_code_entry
)
479 code_record
= record
;
480 record
= table_read (file
);
482 /* create the new data record */
483 new_data
= ZALLOC (model_data
);
484 new_data
->line
= model_record
->line
;
485 filter_parse (&new_data
->flags
,
486 model_record
->field
[record_filter_flags_field
]);
487 new_data
->entry
= model_record
;
488 new_data
->code
= code_record
;
490 while (*list
!= NULL
)
491 list
= &(*list
)->next
;
498 insn_bit_size_option
= 1,
499 insn_specifying_widths_option
,
509 static const name_map option_map
[] = {
510 { "insn-bit-size", insn_bit_size_option
},
511 { "insn-specifying-widths", insn_specifying_widths_option
},
512 { "hi-bit-nr", hi_bit_nr_option
},
513 { "flags-filter", flags_filter_option
},
514 { "model-filter", model_filter_option
},
515 { "multi-sim", multi_sim_option
},
516 { "format-names", format_names_option
},
517 { "gen-delayed-branch", gen_delayed_branch
},
518 { NULL
, unknown_option
},
522 parse_option_record (table
*file
,
525 table_entry
*option_record
;
526 /* parse the option record */
527 option_record
= record
;
528 if (record
->nr_fields
< nr_option_fields
)
529 error (record
->line
, "Incorrect nr of fields for option record\n");
530 record
= table_read (file
);
532 if (!is_filtered_out (options
.flags_filter
,
533 option_record
->field
[record_filter_flags_field
]))
535 char *name
= option_record
->field
[option_name_field
];
536 option_names option
= name2i (name
, option_map
);
537 char *value
= option_record
->field
[option_value_field
];
540 case insn_bit_size_option
:
542 options
.insn_bit_size
= a2i (value
);
543 if (options
.insn_bit_size
< 0
544 || options
.insn_bit_size
> max_insn_bit_size
)
545 error (option_record
->line
, "Instruction bit size out of range\n");
546 if (options
.hi_bit_nr
!= options
.insn_bit_size
- 1
547 && options
.hi_bit_nr
!= 0)
548 error (option_record
->line
, "insn-bit-size / hi-bit-nr conflict\n");
551 case insn_specifying_widths_option
:
553 options
.insn_specifying_widths
= a2i (value
);
556 case hi_bit_nr_option
:
558 options
.hi_bit_nr
= a2i (value
);
559 if (options
.hi_bit_nr
!= 0
560 && options
.hi_bit_nr
!= options
.insn_bit_size
- 1)
561 error (option_record
->line
, "hi-bit-nr / insn-bit-size conflict\n");
564 case flags_filter_option
:
566 filter_parse (&options
.flags_filter
, value
);
569 case model_filter_option
:
571 filter_parse (&options
.model_filter
, value
);
574 case multi_sim_option
:
576 options
.gen
.multi_sim
= a2i (value
);
579 case format_names_option
:
581 filter_parse (&options
.format_name_filter
, value
);
584 case gen_delayed_branch
:
586 options
.gen
.delayed_branch
= a2i (value
);
591 error (option_record
->line
, "Unknown option - %s\n", name
);
600 parse_function_record (table
*file
,
602 function_entry
**list
,
603 function_entry
**list_entry
,
606 function_entry
*new_function
;
607 if (record
->nr_fields
< nr_function_fields
)
608 error (record
->line
, "Missing fields from function record\n");
609 /* look for a body to the function */
610 new_function
= ZALLOC (function_entry
);
611 /* parse the function header */
612 new_function
->line
= record
->line
;
613 filter_parse (&new_function
->flags
,
614 record
->field
[record_filter_flags_field
]);
615 if (record_is_old (record
))
616 new_function
->type
= record
->field
[old_function_typedef_field
];
618 new_function
->type
= record
->field
[function_typedef_field
];
619 new_function
->name
= record
->field
[function_name_field
];
620 if (record
->nr_fields
> function_param_field
)
621 new_function
->param
= record
->field
[function_param_field
];
622 new_function
->is_internal
= is_internal
;
623 /* parse the function body */
624 record
= table_read (file
);
625 if (record
->type
== table_code_entry
)
627 new_function
->code
= record
;
628 record
= table_read (file
);
631 while (*list
!= NULL
)
632 list
= &(*list
)->next
;
633 *list
= new_function
;
634 if (list_entry
!= NULL
)
635 *list_entry
= new_function
;
641 parse_insn_model_record (table
*file
,
646 insn_model_entry
**last_insn_model
;
647 insn_model_entry
*new_insn_model
= ZALLOC (insn_model_entry
);
649 new_insn_model
->line
= record
->line
;
650 if (record
->nr_fields
> insn_model_name_field
)
651 new_insn_model
->name
= record
->field
[insn_model_name_field
];
652 if (record
->nr_fields
> insn_model_unit_data_field
)
653 new_insn_model
->unit_data
= record
->field
[insn_model_unit_data_field
];
654 new_insn_model
->insn
= insn
;
655 /* strip "\*[ ]*" from name */
656 new_insn_model
->name
= skip_spaces (new_insn_model
->name
+ 1);
657 if (strlen (new_insn_model
->name
) == 0)
659 /* No processor name - a generic model entry, enter it into all
660 the non-empty fields */
662 for (index
= 0; index
< model
->nr_models
; index
++)
663 if (insn
->model
[index
] == 0)
665 insn
->model
[index
] = new_insn_model
;
667 /* also add the complete processor set to this processor's set */
668 filter_add (&insn
->processors
, model
->processors
);
672 /* Find the corresponding master model record so it can be
673 linked in correctly */
675 index
= filter_is_member (model
->processors
, new_insn_model
->name
) - 1;
678 error (record
->line
, "machine model `%s' undefined\n",
679 new_insn_model
->name
);
681 /* store it in the corresponding model array entry */
682 insn
->model
[index
] = new_insn_model
;
683 /* also add the name to the instructions processor set as an
684 alternative lookup mechanism */
685 filter_parse (&insn
->processors
, new_insn_model
->name
);
688 /* for some reason record the max length of any
689 function unit field */
690 int len
= strlen (insn_model_ptr
->field
[insn_model_fields
]);
691 if (model
->max_model_fields_len
< len
)
692 model
->max_model_fields_len
= len
;
695 last_insn_model
= &insn
->models
;
696 while ((*last_insn_model
) != NULL
)
697 last_insn_model
= &(*last_insn_model
)->next
;
698 *last_insn_model
= new_insn_model
;
703 parse_insn_mnemonic_record (table
*file
,
707 insn_mnemonic_entry
**last_insn_mnemonic
;
708 insn_mnemonic_entry
*new_insn_mnemonic
= ZALLOC (insn_mnemonic_entry
);
710 new_insn_mnemonic
->line
= record
->line
;
711 ASSERT (record
->nr_fields
> insn_mnemonic_format_field
);
712 new_insn_mnemonic
->format
= record
->field
[insn_mnemonic_format_field
];
713 ASSERT (new_insn_mnemonic
->format
[0] == '"');
714 if (new_insn_mnemonic
->format
[strlen (new_insn_mnemonic
->format
) - 1] != '"')
715 error (new_insn_mnemonic
->line
, "Missing closing double quote in mnemonic field\n");
716 if (record
->nr_fields
> insn_mnemonic_condition_field
)
717 new_insn_mnemonic
->condition
= record
->field
[insn_mnemonic_condition_field
];
718 new_insn_mnemonic
->insn
= insn
;
720 last_insn_mnemonic
= &insn
->mnemonics
;
721 while ((*last_insn_mnemonic
) != NULL
)
722 last_insn_mnemonic
= &(*last_insn_mnemonic
)->next
;
723 insn
->nr_mnemonics
++;
724 *last_insn_mnemonic
= new_insn_mnemonic
;
729 load_insn_table (char *file_name
,
732 table
*file
= table_open (file_name
);
733 table_entry
*record
= table_read (file
);
735 insn_table
*isa
= ZALLOC (insn_table
);
736 model_table
*model
= ZALLOC (model_table
);
741 while (record
!= NULL
)
744 switch (record_type (record
))
749 if (isa
->insns
!= NULL
)
750 error (record
->line
, "Option after first instruction\n");
751 record
= parse_option_record (file
, record
);
755 case string_function_record
:
757 /* convert a string function field into an internal function field */
759 if (record
->nr_fields
< nr_function_fields
)
760 error (record
->line
, "Incorrect nr of fields for %s record\n");
761 name
= NZALLOC (char,
763 + strlen (record
->field
[function_name_field
])
765 strcat (name
, "str_");
766 strcat (name
, record
->field
[function_name_field
]);
767 record
->field
[record_type_field
] = "function";
768 record
->field
[function_typedef_field
] = "const char *";
769 record
->field
[function_name_field
] = name
;
770 /* HACK - comes round back as a function/internal record */
774 case function_record
: /* function record */
776 record
= parse_function_record (file
, record
,
783 case internal_record
:
785 /* only insert it into the function list if it is unknown */
786 function_entry
*function
= NULL
;
787 record
= parse_function_record (file
, record
,
791 /* check what was inserted to see if a pseudo-instruction
792 entry also needs to be created */
793 if (function
!= NULL
)
795 insn_entry
**insn
= NULL
;
796 if (strcmp (function
->name
, "illegal") == 0)
798 /* illegal function save it away */
799 if (isa
->illegal_insn
!= NULL
)
801 warning (function
->line
,
802 "Multiple illegal instruction definitions\n");
803 error (isa
->illegal_insn
->line
,
804 "Location of first illegal instruction\n");
807 insn
= &isa
->illegal_insn
;
811 *insn
= ZALLOC (insn_entry
);
812 (*insn
)->line
= function
->line
;
813 (*insn
)->name
= function
->name
;
814 (*insn
)->code
= function
->code
;
820 case scratch_record
: /* cache macro records */
824 cache_entry
*new_cache
;
825 /* parse the cache record */
826 if (record
->nr_fields
< nr_cache_fields
)
828 "Incorrect nr of fields for scratch/cache/compute record\n");
830 new_cache
= ZALLOC (cache_entry
);
831 new_cache
->line
= record
->line
;
832 filter_parse (&new_cache
->flags
,
833 record
->field
[record_filter_flags_field
]);
834 new_cache
->type
= record
->field
[cache_type_field
];
835 new_cache
->name
= record
->field
[cache_name_field
];
836 filter_parse (&new_cache
->original_fields
,
837 record
->field
[cache_original_fields_field
]);
838 new_cache
->expression
= record
->field
[cache_expression_field
];
839 /* insert it but only if not filtered out */
840 if (!filter_is_subset (options
.flags_filter
, new_cache
->flags
))
842 notify (new_cache
->line
, "Discarding cache entry %s\n",
849 while (*last
!= NULL
)
850 last
= &(*last
)->next
;
854 record
= table_read (file
);
859 case model_processor_record
:
861 model_entry
*new_model
;
862 /* parse the model */
863 if (record
->nr_fields
< nr_model_processor_fields
)
864 error (record
->line
, "Incorrect nr of fields for model record\n");
865 if (isa
->insns
!= NULL
)
866 error (record
->line
, "Model appears after first instruction\n");
867 new_model
= ZALLOC (model_entry
);
868 filter_parse (&new_model
->flags
,
869 record
->field
[record_filter_flags_field
]);
870 new_model
->line
= record
->line
;
871 new_model
->name
= record
->field
[model_name_field
];
872 new_model
->full_name
= record
->field
[model_full_name_field
];
873 new_model
->unit_data
= record
->field
[model_unit_data_field
];
874 /* only insert it if not filtered out */
875 if (!filter_is_subset (options
.flags_filter
, new_model
->flags
))
877 notify (new_model
->line
, "Discarding processor model %s\n",
880 else if (filter_is_member (model
->processors
, new_model
->name
))
882 error (new_model
->line
, "Duplicate processor model %s\n",
888 last
= &model
->models
;
889 while (*last
!= NULL
)
890 last
= &(*last
)->next
;
894 filter_parse (&model
->processors
, new_model
->name
);
897 record
= table_read (file
);
901 case model_macro_record
:
902 record
= parse_model_data_record (isa
, file
, record
,
903 nr_model_macro_fields
,
907 case model_data_record
:
908 record
= parse_model_data_record (isa
, file
, record
,
909 nr_model_data_fields
,
913 case model_static_record
:
914 record
= parse_function_record (file
, record
,
920 case model_internal_record
:
921 record
= parse_function_record (file
, record
,
927 case model_function_record
:
928 record
= parse_function_record (file
, record
,
934 case insn_record
: /* instruction records */
936 insn_entry
*new_insn
;
938 /* parse the instruction */
939 if (record
->nr_fields
< nr_insn_fields
)
940 error (record
->line
, "Incorrect nr of fields for insn record\n");
941 new_insn
= ZALLOC (insn_entry
);
942 new_insn
->line
= record
->line
;
943 filter_parse (&new_insn
->flags
,
944 record
->field
[record_filter_flags_field
]);
945 /* save the format field. Can't parse it until after the
946 filter-out checks. Could be filtered out because the
948 format
= record
->field
[insn_word_field
];
949 new_insn
->format_name
= record
->field
[insn_format_name_field
];
950 if (options
.format_name_filter
!= NULL
951 && !filter_is_member (options
.format_name_filter
,
952 new_insn
->format_name
))
953 error (new_insn
->line
, "Unreconized instruction format name `%s'\n",
954 new_insn
->format_name
);
955 filter_parse (&new_insn
->options
,
956 record
->field
[insn_options_field
]);
957 new_insn
->name
= record
->field
[insn_name_field
];
958 record
= table_read (file
);
959 /* Parse any model/assember records */
960 new_insn
->nr_models
= model
->nr_models
;
961 new_insn
->model
= NZALLOC (insn_model_entry
*, model
->nr_models
+ 1);
962 while (record
!= NULL
)
964 if (record_prefix_is (record
, '*', nr_insn_model_fields
))
965 parse_insn_model_record (file
, record
, new_insn
, model
);
966 else if (record_prefix_is (record
, '"', nr_insn_mnemonic_fields
))
967 parse_insn_mnemonic_record (file
, record
, new_insn
);
971 record
= table_read (file
);
973 /* Parse the code record */
974 if (record
!= NULL
&& record
->type
== table_code_entry
)
976 new_insn
->code
= record
;
977 record
= table_read (file
);
980 if (!filter_is_subset (options
.flags_filter
, new_insn
->flags
))
982 if (options
.warn
.discard
)
983 notify (new_insn
->line
,
984 "Discarding instruction %s (flags-filter)\n",
987 else if (new_insn
->processors
!= NULL
988 && options
.model_filter
!= NULL
989 && !filter_is_common (options
.model_filter
,
990 new_insn
->processors
))
992 /* only discard an instruction based in the processor
993 model when both the instruction and the options are
995 if (options
.warn
.discard
)
996 notify (new_insn
->line
,
997 "Discarding instruction %s (processor-model)\n",
1003 /* finish the parsing */
1004 parse_insn_words (new_insn
, format
);
1008 last
= &(*last
)->next
;
1010 /* update global isa counters */
1012 if (isa
->max_nr_words
< new_insn
->nr_words
)
1013 isa
->max_nr_words
= new_insn
->nr_words
;
1014 filter_add (&isa
->flags
, new_insn
->flags
);
1015 filter_add (&isa
->options
, new_insn
->options
);
1021 error (record
->line
, "Unknown entry\n");
1029 print_insn_words (lf
*file
,
1032 insn_word_entry
*word
= insn
->words
;
1037 insn_field_entry
*field
= word
->first
;
1040 if (options
.insn_specifying_widths
)
1041 lf_printf (file
, "%d.", field
->width
);
1043 lf_printf (file
, "%d.", i2target (options
.hi_bit_nr
, field
->first
));
1044 switch (field
->type
)
1046 case insn_field_int
:
1047 lf_printf (file
, "0x%lx", (long) field
->val_int
);
1049 case insn_field_reserved
:
1050 lf_printf (file
, "/");
1052 case insn_field_wild
:
1053 lf_printf (file
, "*");
1055 case insn_field_string
:
1056 lf_printf (file
, "%s", field
->val_string
);
1059 if (field
== word
->last
)
1061 field
= field
->next
;
1062 lf_printf (file
, ",");
1067 lf_printf (file
, "+");
1075 function_entry_traverse (lf
*file
,
1076 function_entry
*functions
,
1077 function_entry_handler
*handler
,
1080 function_entry
*function
;
1081 for (function
= functions
; function
!= NULL
; function
= function
->next
)
1083 handler (file
, function
, data
);
1088 insn_table_traverse_insn (lf
*file
,
1090 insn_entry_handler
*handler
,
1094 for (insn
= isa
->insns
; insn
!= NULL
; insn
= insn
->next
)
1096 handler (file
, isa
, insn
, data
);
1102 dump_function_entry (lf
*file
,
1104 function_entry
*entry
,
1107 lf_printf (file
, "%s(function_entry *) 0x%lx", prefix
, (long) entry
);
1110 dump_line_ref (file
, "\n(line ", entry
->line
, ")");
1111 dump_filter (file
, "\n(flags ", entry
->flags
, ")");
1112 lf_printf (file
, "\n(type \"%s\")", entry
->type
);
1113 lf_printf (file
, "\n(name \"%s\")", entry
->name
);
1114 lf_printf (file
, "\n(param \"%s\")", entry
->param
);
1115 dump_table_entry (file
, "\n(code ", entry
->code
, ")");
1116 lf_printf (file
, "\n(is_internal %d)", entry
->is_internal
);
1117 lf_printf (file
, "\n(next 0x%lx)", (long) entry
->next
);
1119 lf_printf (file
, "%s", suffix
);
1123 dump_function_entries (lf
*file
,
1125 function_entry
*entry
,
1128 lf_printf (file
, "%s", prefix
);
1129 lf_indent (file
, +1);
1130 while (entry
!= NULL
)
1132 dump_function_entry (file
, "\n(", entry
, ")");
1133 entry
= entry
->next
;
1135 lf_indent (file
, -1);
1136 lf_printf (file
, "%s", suffix
);
1140 cache_entry_type_to_str (cache_entry_type type
)
1144 case scratch_value
: return "scratch";
1145 case cache_value
: return "cache";
1146 case compute_value
: return "compute";
1148 ERROR ("Bad switch");
1153 dump_cache_entry (lf
*file
,
1158 lf_printf (file
, "%s(cache_entry *) 0x%lx", prefix
, (long) entry
);
1161 dump_line_ref (file
, "\n(line ", entry
->line
, ")");
1162 dump_filter (file
, "\n(flags ", entry
->flags
, ")");
1163 lf_printf (file
, "\n(entry_type \"%s\")", cache_entry_type_to_str (entry
->entry_type
));
1164 lf_printf (file
, "\n(name \"%s\")", entry
->name
);
1165 dump_filter (file
, "\n(original_fields ", entry
->original_fields
, ")");
1166 lf_printf (file
, "\n(type \"%s\")", entry
->type
);
1167 lf_printf (file
, "\n(expression \"%s\")", entry
->expression
);
1168 lf_printf (file
, "\n(next 0x%lx)", (long) entry
->next
);
1170 lf_printf (file
, "%s", suffix
);
1174 dump_cache_entries (lf
*file
,
1179 lf_printf (file
, "%s", prefix
);
1180 lf_indent (file
, +1);
1181 while (entry
!= NULL
)
1183 dump_cache_entry (file
, "\n(", entry
, ")");
1184 entry
= entry
->next
;
1186 lf_indent (file
, -1);
1187 lf_printf (file
, "%s", suffix
);
1191 dump_model_data (lf
*file
,
1196 lf_printf (file
, "%s(model_data *) 0x%lx", prefix
, (long) entry
);
1199 lf_indent (file
, +1);
1200 dump_line_ref (file
, "\n(line ", entry
->line
, ")");
1201 dump_filter (file
, "\n(flags ", entry
->flags
, ")");
1202 dump_table_entry (file
, "\n(entry ", entry
->entry
, ")");
1203 dump_table_entry (file
, "\n(code ", entry
->code
, ")");
1204 lf_printf (file
, "\n(next 0x%lx)", (long) entry
->next
);
1205 lf_indent (file
, -1);
1207 lf_printf (file
, "%s", prefix
);
1211 dump_model_datas (lf
*file
,
1216 lf_printf (file
, "%s", prefix
);
1217 lf_indent (file
, +1);
1218 while (entry
!= NULL
)
1220 dump_model_data (file
, "\n(", entry
, ")");
1221 entry
= entry
->next
;
1223 lf_indent (file
, -1);
1224 lf_printf (file
, "%s", suffix
);
1228 dump_model_entry (lf
*file
,
1233 lf_printf (file
, "%s(model_entry *) 0x%lx", prefix
, (long) entry
);
1236 lf_indent (file
, +1);
1237 dump_line_ref (file
, "\n(line ", entry
->line
, ")");
1238 dump_filter (file
, "\n(flags ", entry
->flags
, ")");
1239 lf_printf (file
, "\n(name \"%s\")", entry
->name
);
1240 lf_printf (file
, "\n(full_name \"%s\")", entry
->full_name
);
1241 lf_printf (file
, "\n(unit_data \"%s\")", entry
->unit_data
);
1242 lf_printf (file
, "\n(next 0x%lx)", (long) entry
->next
);
1243 lf_indent (file
, -1);
1245 lf_printf (file
, "%s", prefix
);
1249 dump_model_entries (lf
*file
,
1254 lf_printf (file
, "%s", prefix
);
1255 lf_indent (file
, +1);
1256 while (entry
!= NULL
)
1258 dump_model_entry (file
, "\n(", entry
, ")");
1259 entry
= entry
->next
;
1261 lf_indent (file
, -1);
1262 lf_printf (file
, "%s", suffix
);
1267 dump_model_table (lf
*file
,
1272 lf_printf (file
, "%s(model_table *) 0x%lx", prefix
, (long) entry
);
1275 lf_indent (file
, +1);
1276 dump_filter (file
, "\n(processors ", entry
->processors
, ")");
1277 lf_printf (file
, "\n(nr_models %d)", entry
->nr_models
);
1278 dump_model_entries (file
, "\n(models ", entry
->models
, ")");
1279 dump_model_datas (file
, "\n(macros ", entry
->macros
, ")");
1280 dump_model_datas (file
, "\n(data ", entry
->data
, ")");
1281 dump_function_entries (file
, "\n(statics ", entry
->statics
, ")");
1282 dump_function_entries (file
, "\n(internals ", entry
->functions
, ")");
1283 dump_function_entries (file
, "\n(functions ", entry
->functions
, ")");
1284 lf_indent (file
, -1);
1286 lf_printf (file
, "%s", suffix
);
1291 insn_field_type_to_str (insn_field_type type
)
1295 case insn_field_int
: return "int";
1296 case insn_field_reserved
: return "reserved";
1297 case insn_field_wild
: return "wild";
1298 case insn_field_string
: return "string";
1300 ERROR ("bad switch");
1305 dump_insn_field (lf
*file
,
1307 insn_field_entry
*field
,
1311 lf_printf (file
, "%s(insn_field_entry *) 0x%lx", prefix
, (long) field
);
1314 lf_indent (file
, +1);
1315 lf_printf (file
, "%s(first %d)", sep
, field
->first
);
1316 lf_printf (file
, "%s(last %d)", sep
, field
->last
);
1317 lf_printf (file
, "%s(width %d)", sep
, field
->width
);
1318 lf_printf (file
, "%s(type %s)", sep
, insn_field_type_to_str (field
->type
));
1319 switch (field
->type
)
1321 case insn_field_int
:
1322 lf_printf (file
, "%s(val 0x%lx)", sep
, (long) field
->val_int
);
1324 case insn_field_reserved
:
1325 /* nothing output */
1327 case insn_field_wild
:
1328 /* nothing output */
1330 case insn_field_string
:
1331 lf_printf (file
, "%s(val \"%s\")", sep
, field
->val_string
);
1334 lf_printf (file
, "%s(next 0x%lx)", sep
, (long) field
->next
);
1335 lf_printf (file
, "%s(prev 0x%lx)", sep
, (long) field
->prev
);
1336 lf_indent (file
, -1);
1338 lf_printf (file
, "%s", suffix
);
1342 dump_insn_word_entry (lf
*file
,
1344 insn_word_entry
*word
,
1347 lf_printf (file
, "%s(insn_word_entry *) 0x%lx", prefix
, (long) word
);
1351 insn_field_entry
*field
;
1352 lf_indent (file
, +1);
1353 lf_printf (file
, "\n(first 0x%lx)", (long) word
->first
);
1354 lf_printf (file
, "\n(last 0x%lx)", (long) word
->last
);
1355 lf_printf (file
, "\n(bit");
1356 for (i
= 0; i
< options
.insn_bit_size
; i
++)
1357 lf_printf (file
, "\n ((value %d) (mask %d) (field 0x%lx))",
1358 word
->bit
[i
]->value
, word
->bit
[i
]->mask
, (long) word
->bit
[i
]->field
);
1359 lf_printf (file
, ")");
1360 for (field
= word
->first
; field
!= NULL
; field
= field
->next
)
1361 dump_insn_field (file
, "\n(", field
, ")");
1362 dump_filter (file
, "\n(field_names ", word
->field_names
, ")");
1363 lf_printf (file
, "\n(next 0x%lx)", (long) word
->next
);
1364 lf_indent (file
, -1);
1366 lf_printf (file
, "%s", suffix
);
1370 dump_insn_word_entries (lf
*file
,
1372 insn_word_entry
*word
,
1375 lf_printf (file
, "%s", prefix
);
1376 while (word
!= NULL
)
1378 dump_insn_word_entry (file
, "\n(", word
, ")");
1381 lf_printf (file
, "%s", suffix
);
1385 dump_insn_model_entry (lf
*file
,
1387 insn_model_entry
*model
,
1390 lf_printf (file
, "%s(insn_model_entry *) 0x%lx", prefix
, (long) model
);
1393 lf_indent (file
, +1);
1394 dump_line_ref (file
, "\n(line ", model
->line
, ")");
1395 lf_printf (file
, "\n(name \"%s\")", model
->name
);
1396 lf_printf (file
, "\n(full_name \"%s\")", model
->full_name
);
1397 lf_printf (file
, "\n(unit_data \"%s\")", model
->unit_data
);
1398 lf_printf (file
, "\n(insn (insn_entry *) 0x%lx)", (long) model
->insn
);
1399 lf_printf (file
, "\n(next (insn_model_entry *) 0x%lx)",
1400 (long) model
->next
);
1401 lf_indent (file
, -1);
1403 lf_printf (file
, "%s", suffix
);
1407 dump_insn_model_entries (lf
*file
,
1409 insn_model_entry
*model
,
1412 lf_printf (file
, "%s", prefix
);
1413 while (model
!= NULL
)
1415 dump_insn_model_entry (file
, "\n", model
, "");
1416 model
= model
->next
;
1418 lf_printf (file
, "%s", suffix
);
1423 dump_insn_mnemonic_entry (lf
*file
,
1425 insn_mnemonic_entry
*mnemonic
,
1428 lf_printf (file
, "%s(insn_mnemonic_entry *) 0x%lx", prefix
, (long) mnemonic
);
1429 if (mnemonic
!= NULL
)
1431 lf_indent (file
, +1);
1432 dump_line_ref (file
, "\n(line ", mnemonic
->line
, ")");
1433 lf_printf (file
, "\n(format \"%s\")", mnemonic
->format
);
1434 lf_printf (file
, "\n(condition \"%s\")", mnemonic
->condition
);
1435 lf_printf (file
, "\n(insn (insn_entry *) 0x%lx)",
1436 (long) mnemonic
->insn
);
1437 lf_printf (file
, "\n(next (insn_mnemonic_entry *) 0x%lx)",
1438 (long) mnemonic
->next
);
1439 lf_indent (file
, -1);
1441 lf_printf (file
, "%s", suffix
);
1445 dump_insn_mnemonic_entries (lf
*file
,
1447 insn_mnemonic_entry
*mnemonic
,
1450 lf_printf (file
, "%s", prefix
);
1451 while (mnemonic
!= NULL
)
1453 dump_insn_mnemonic_entry (file
, "\n", mnemonic
, "");
1454 mnemonic
= mnemonic
->next
;
1456 lf_printf (file
, "%s", suffix
);
1460 dump_insn_entry (lf
*file
,
1465 lf_printf (file
, "%s(insn_entry *) 0x%lx", prefix
, (long) entry
);
1469 lf_indent (file
, +1);
1470 dump_line_ref (file
, "\n(line ", entry
->line
, ")");
1471 dump_filter (file
, "\n(flags ", entry
->flags
, ")");
1472 lf_printf (file
, "\n(nr_words %d)", entry
->nr_words
);
1473 dump_insn_word_entries (file
, "\n(words ", entry
->words
, ")");
1474 lf_printf (file
, "\n(word");
1475 for (i
= 0; i
< entry
->nr_models
; i
++)
1476 lf_printf (file
, " 0x%lx", (long) entry
->word
[i
]);
1477 lf_printf (file
, ")");
1478 dump_filter (file
, "\n(field_names ", entry
->field_names
, ")");
1479 lf_printf (file
, "\n(format_name \"%s\")", entry
->format_name
);
1480 dump_filter (file
, "\n(options ", entry
->options
, ")");
1481 lf_printf (file
, "\n(name \"%s\")", entry
->name
);
1482 lf_printf (file
, "\n(nr_models %d)", entry
->nr_models
);
1483 dump_insn_model_entries (file
, "\n(models ", entry
->models
, ")");
1484 lf_printf (file
, "\n(model");
1485 for (i
= 0; i
< entry
->nr_models
; i
++)
1486 lf_printf (file
, " 0x%lx", (long) entry
->model
[i
]);
1487 lf_printf (file
, ")");
1488 dump_filter (file
, "\n(processors ", entry
->processors
, ")");
1489 dump_insn_mnemonic_entries (file
, "\n(mnemonics ", entry
->mnemonics
, ")");
1490 dump_table_entry (file
, "\n(code ", entry
->code
, ")");
1491 lf_printf (file
, "\n(next 0x%lx)", (long) entry
->next
);
1492 lf_indent (file
, -1);
1494 lf_printf (file
, "%s", suffix
);
1498 dump_insn_entries (lf
*file
,
1503 lf_printf (file
, "%s", prefix
);
1504 lf_indent (file
, +1);
1505 while (entry
!= NULL
)
1507 dump_insn_entry (file
, "\n(", entry
, ")");
1508 entry
= entry
->next
;
1510 lf_indent (file
, -1);
1511 lf_printf (file
, "%s", suffix
);
1517 dump_insn_table (lf
*file
,
1522 lf_printf (file
, "%s(insn_table *) 0x%lx", prefix
, (long) isa
);
1525 lf_indent (file
, +1);
1526 dump_cache_entries (file
, "\n(caches ", isa
->caches
, ")");
1527 lf_printf (file
, "\n(nr_insns %d)", isa
->nr_insns
);
1528 lf_printf (file
, "\n(max_nr_words %d)", isa
->max_nr_words
);
1529 dump_insn_entries (file
, "\n(insns ", isa
->insns
, ")");
1530 dump_function_entries (file
, "\n(functions ", isa
->functions
, ")");
1531 dump_insn_entry (file
, "\n(illegal_insn ", isa
->illegal_insn
, ")");
1532 dump_model_table (file
, "\n(model ", isa
->model
, ")");
1533 dump_filter (file
, "\n(flags ", isa
->flags
, ")");
1534 dump_filter (file
, "\n(options ", isa
->options
, ")");
1535 lf_indent (file
, -1);
1537 lf_printf (file
, "%s", suffix
);
1542 igen_options options
;
1545 main (int argc
, char **argv
)
1550 INIT_OPTIONS (options
);
1553 filter_parse (&options
.flags_filter
, argv
[2]);
1555 error (NULL
, "Usage: insn <insn-table> [ <filter-in> ]\n");
1557 isa
= load_insn_table (argv
[1], NULL
);
1558 l
= lf_open ("-", "stdout", lf_omit_references
, lf_is_text
, "tmp-ld-insn");
1559 dump_insn_table (l
, "(isa ", isa
, ")\n");