1 /* The IGEN simulator generator for GDB, the GNU Debugger.
3 Copyright 2002, 2007 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 #include "ld-decode.h"
34 #include "gen-semantics.h"
35 #include "gen-idecode.h"
36 #include "gen-icache.h"
41 print_icache_function_header (lf *file,
43 const char *format_name,
44 opcode_bits *expanded_bits,
45 int is_function_definition,
46 int nr_prefetched_words)
48 lf_printf (file, "\n");
49 lf_print__function_type_function (file, print_icache_function_type,
50 "EXTERN_ICACHE", " ");
51 print_function_name (file,
52 basename, format_name, NULL,
53 expanded_bits, function_name_prefix_icache);
54 lf_printf (file, "\n(");
55 print_icache_function_formal (file, nr_prefetched_words);
56 lf_printf (file, ")");
57 if (!is_function_definition)
58 lf_printf (file, ";");
59 lf_printf (file, "\n");
64 print_icache_declaration (lf *file,
66 opcode_bits *expanded_bits,
67 insn_opcodes *opcodes, int nr_prefetched_words)
69 print_icache_function_header (file,
73 0 /* is not function definition */ ,
80 print_icache_extraction (lf *file,
81 const char *format_name,
82 cache_entry_type cache_type,
83 const char *entry_name,
84 const char *entry_type,
85 const char *entry_expression,
86 char *single_insn_field,
88 insn_field_entry *cur_field,
89 opcode_bits *expanded_bits,
90 icache_decl_type what_to_declare,
91 icache_body_type what_to_do)
93 const char *expression;
96 ASSERT (format_name != NULL);
97 ASSERT (entry_name != NULL);
99 /* figure out exactly what should be going on here */
103 if ((what_to_do & put_values_in_icache)
104 || what_to_do == do_not_use_icache)
107 what_to_do = do_not_use_icache;
113 if ((what_to_do & get_values_from_icache)
114 || what_to_do == do_not_use_icache)
117 what_to_do = do_not_use_icache;
123 if ((what_to_declare != undef_variables)
124 || !(what_to_do & put_values_in_icache))
127 what_to_declare = ((what_to_do & put_values_in_icache)
128 ? declare_variables : what_to_declare);
134 abort (); /* Bad switch. */
137 /* For the type, default to a simple unsigned */
138 if (entry_type == NULL || strlen (entry_type) == 0)
139 entry_type = "unsigned";
141 /* look through the set of expanded sub fields to see if this field
142 has been given a constant value */
143 for (bits = expanded_bits; bits != NULL; bits = bits->next)
145 if (bits->field == cur_field)
149 /* Define a storage area for the cache element */
150 switch (what_to_declare)
152 case undef_variables:
153 /* We've finished with the #define value - destory it */
154 lf_indent_suppress (file);
155 lf_printf (file, "#undef %s\n", entry_name);
157 case define_variables:
158 /* Using direct access for this entry, clear any prior
159 definition, then define it */
160 lf_indent_suppress (file);
161 lf_printf (file, "#undef %s\n", entry_name);
162 /* Don't type cast pointer types! */
163 lf_indent_suppress (file);
164 if (strchr (entry_type, '*') != NULL)
165 lf_printf (file, "#define %s (", entry_name);
167 lf_printf (file, "#define %s ((%s) ", entry_name, entry_type);
169 case declare_variables:
170 /* using variables to define the value */
172 lf_print__line_ref (file, line);
173 lf_printf (file, "%s const %s UNUSED = ", entry_type, entry_name);
178 /* define a value for that storage area as determined by what is in
181 && single_insn_field != NULL
182 && strcmp (entry_name, single_insn_field) == 0
183 && strcmp (entry_name, cur_field->val_string) == 0
184 && ((bits->opcode->is_boolean && bits->value == 0)
185 || (!bits->opcode->is_boolean)))
187 /* The cache rule is specifying what to do with a simple
190 Because of instruction expansion, the field is either a
191 constant value or equal to the specified constant (boolean
192 comparison). (The latter indicated by bits->value == 0).
194 The case of a field not being equal to the specified boolean
195 value is handled later. */
196 expression = "constant field";
197 ASSERT (bits->field == cur_field);
198 if (bits->opcode->is_boolean)
200 ASSERT (bits->value == 0);
201 lf_printf (file, "%d", bits->opcode->boolean_constant);
203 else if (bits->opcode->last < bits->field->last)
205 lf_printf (file, "%d",
206 bits->value << (bits->field->last - bits->opcode->last));
210 lf_printf (file, "%d", bits->value);
213 else if (bits != NULL
214 && single_insn_field != NULL
215 && strncmp (entry_name,
217 strlen (single_insn_field)) == 0
218 && strncmp (entry_name + strlen (single_insn_field),
220 strlen ("_is_")) == 0
221 && ((bits->opcode->is_boolean
223 atol (entry_name + strlen (single_insn_field) +
224 strlen ("_is_")) == bits->opcode->boolean_constant))
225 || (!bits->opcode->is_boolean)))
227 /* The cache rule defines an entry for the comparison between a
228 single instruction field and a constant. The value of the
229 comparison in someway matches that of the opcode field that
230 was made constant through expansion. */
231 expression = "constant compare";
232 if (bits->opcode->is_boolean)
234 lf_printf (file, "%d /* %s == %d */",
236 single_insn_field, bits->opcode->boolean_constant);
238 else if (bits->opcode->last < bits->field->last)
240 lf_printf (file, "%d /* %s == %d */",
242 (entry_name + strlen (single_insn_field) +
245 value << (bits->field->last - bits->opcode->last))),
248 value << (bits->field->last - bits->opcode->last)));
252 lf_printf (file, "%d /* %s == %d */",
254 (entry_name + strlen (single_insn_field) +
255 strlen ("_is_")) == bits->value), single_insn_field,
261 /* put the field in the local variable, possibly also enter it
263 expression = "extraction";
264 /* handle the cache */
265 if ((what_to_do & get_values_from_icache)
266 || (what_to_do & put_values_in_icache))
268 lf_printf (file, "cache_entry->crack.%s.%s",
269 format_name, entry_name);
270 if (what_to_do & put_values_in_icache) /* also put it in the cache? */
272 lf_printf (file, " = ");
275 if ((what_to_do & put_values_in_icache)
276 || what_to_do == do_not_use_icache)
278 if (cur_field != NULL)
280 if (entry_expression != NULL && strlen (entry_expression) > 0)
282 "Instruction field entry with nonempty expression\n");
283 if (cur_field->first == 0
284 && cur_field->last == options.insn_bit_size - 1)
285 lf_printf (file, "(instruction_%d)", cur_field->word_nr);
286 else if (cur_field->last == options.insn_bit_size - 1)
287 lf_printf (file, "MASKED%d (instruction_%d, %d, %d)",
288 options.insn_bit_size,
290 i2target (options.hi_bit_nr, cur_field->first),
291 i2target (options.hi_bit_nr, cur_field->last));
293 lf_printf (file, "EXTRACTED%d (instruction_%d, %d, %d)",
294 options.insn_bit_size,
296 i2target (options.hi_bit_nr, cur_field->first),
297 i2target (options.hi_bit_nr, cur_field->last));
301 lf_printf (file, "%s", entry_expression);
306 switch (what_to_declare)
308 case define_variables:
309 lf_printf (file, ")");
311 case undef_variables:
313 case declare_variables:
314 lf_printf (file, ";");
318 ASSERT (reason != NULL && expression != NULL);
319 lf_printf (file, " /* %s - %s */\n", reason, expression);
324 print_icache_body (lf *file,
325 insn_entry * instruction,
326 opcode_bits *expanded_bits,
327 cache_entry *cache_rules,
328 icache_decl_type what_to_declare,
329 icache_body_type what_to_do, int nr_prefetched_words)
331 /* extract instruction fields */
332 lf_printf (file, "/* Extraction: %s\n", instruction->name);
333 lf_printf (file, " ");
334 switch (what_to_declare)
336 case define_variables:
337 lf_printf (file, "#define");
339 case declare_variables:
340 lf_printf (file, "declare");
342 case undef_variables:
343 lf_printf (file, "#undef");
346 lf_printf (file, " ");
349 case get_values_from_icache:
350 lf_printf (file, "get-values-from-icache");
352 case put_values_in_icache:
353 lf_printf (file, "put-values-in-icache");
355 case both_values_and_icache:
356 lf_printf (file, "get-values-from-icache|put-values-in-icache");
358 case do_not_use_icache:
359 lf_printf (file, "do-not-use-icache");
362 lf_printf (file, "\n ");
363 print_insn_words (file, instruction);
364 lf_printf (file, " */\n");
366 /* pass zero - fetch from memory any missing instructions.
368 Some of the instructions will have already been fetched (in the
369 instruction array), others will still need fetching. */
372 case get_values_from_icache:
374 case put_values_in_icache:
375 case both_values_and_icache:
376 case do_not_use_icache:
379 switch (what_to_declare)
381 case undef_variables:
383 case define_variables:
384 case declare_variables:
385 for (word_nr = nr_prefetched_words;
386 word_nr < instruction->nr_words; word_nr++)
388 /* FIXME - should be using print_icache_extraction? */
390 "%sinstruction_word instruction_%d UNUSED = ",
391 options.module.global.prefix.l, word_nr);
392 lf_printf (file, "IMEM%d_IMMED (cia, %d)",
393 options.insn_bit_size, word_nr);
394 lf_printf (file, ";\n");
400 /* if putting the instruction words in the cache, define references
402 if (options.gen.insn_in_icache)
404 /* FIXME: is the instruction_word type correct? */
405 print_icache_extraction (file, instruction->format_name, cache_value, "insn", /* name */
406 "instruction_word", /* type */
407 "instruction", /* expression */
410 NULL, NULL, what_to_declare, what_to_do);
412 lf_printf (file, "\n");
414 /* pass one - process instruction fields.
416 If there is no cache rule, the default is to enter the field into
419 insn_word_entry *word;
420 for (word = instruction->words; word != NULL; word = word->next)
422 insn_field_entry *cur_field;
423 for (cur_field = word->first;
424 cur_field->first < options.insn_bit_size;
425 cur_field = cur_field->next)
427 if (cur_field->type == insn_field_string)
429 cache_entry *cache_rule;
430 cache_entry_type value_type = cache_value;
431 line_ref *value_line = instruction->line;
432 /* check the cache table to see if it contains a rule
433 overriding the default cache action for an
435 for (cache_rule = cache_rules;
436 cache_rule != NULL; cache_rule = cache_rule->next)
438 if (filter_is_subset (instruction->field_names,
439 cache_rule->original_fields)
440 && strcmp (cache_rule->name,
441 cur_field->val_string) == 0)
443 value_type = cache_rule->entry_type;
444 value_line = cache_rule->line;
445 if (value_type == compute_value)
447 options.warning (cache_rule->line,
448 "instruction field of type `compute' changed to `cache'\n");
449 cache_rule->entry_type = cache_value;
454 /* Define an entry for the field within the
456 print_icache_extraction (file, instruction->format_name, value_type, cur_field->val_string, /* name */
458 NULL, /* expression */
459 cur_field->val_string, /* insn field */
463 what_to_declare, what_to_do);
469 /* pass two - any cache fields not processed above */
471 cache_entry *cache_rule;
472 for (cache_rule = cache_rules;
473 cache_rule != NULL; cache_rule = cache_rule->next)
475 if (filter_is_subset (instruction->field_names,
476 cache_rule->original_fields)
477 && !filter_is_member (instruction->field_names, cache_rule->name))
480 filter_next (cache_rule->original_fields, "");
481 if (filter_next (cache_rule->original_fields, single_field) !=
484 print_icache_extraction (file, instruction->format_name, cache_rule->entry_type, cache_rule->name, cache_rule->type, cache_rule->expression, single_field, cache_rule->line, NULL, /* cur_field */
486 what_to_declare, what_to_do);
491 lf_print__internal_ref (file);
496 typedef struct _form_fields form_fields;
505 insn_table_cache_fields (insn_table *isa)
507 form_fields *forms = NULL;
509 for (insn = isa->insns; insn != NULL; insn = insn->next)
511 form_fields **form = &forms;
516 /* new format name, add it */
517 form_fields *new_form = ZALLOC (form_fields);
518 new_form->name = insn->format_name;
519 filter_add (&new_form->fields, insn->field_names);
523 else if (strcmp ((*form)->name, insn->format_name) == 0)
525 /* already present, add field names to the existing list */
526 filter_add (&(*form)->fields, insn->field_names);
529 form = &(*form)->next;
538 print_icache_struct (lf *file, insn_table *isa, cache_entry *cache_rules)
540 /* Create a list of all the different instruction formats with their
541 corresponding field names. */
542 form_fields *formats = insn_table_cache_fields (isa);
544 lf_printf (file, "\n");
545 lf_printf (file, "#define WITH_%sIDECODE_CACHE_SIZE %d\n",
546 options.module.global.prefix.u,
547 (options.gen.icache ? options.gen.icache_size : 0));
548 lf_printf (file, "\n");
550 /* create an instruction cache if being used */
551 if (options.gen.icache)
553 lf_printf (file, "typedef struct _%sidecode_cache {\n",
554 options.module.global.prefix.l);
555 lf_indent (file, +2);
558 lf_printf (file, "unsigned_word address;\n");
559 lf_printf (file, "void *semantic;\n");
560 lf_printf (file, "union {\n");
561 lf_indent (file, +2);
562 for (format = formats; format != NULL; format = format->next)
564 lf_printf (file, "struct {\n");
565 lf_indent (file, +2);
567 cache_entry *cache_rule;
569 /* space for any instruction words */
570 if (options.gen.insn_in_icache)
571 lf_printf (file, "instruction_word insn[%d];\n",
573 /* define an entry for any applicable cache rules */
574 for (cache_rule = cache_rules;
575 cache_rule != NULL; cache_rule = cache_rule->next)
577 /* nb - sort of correct - should really check against
578 individual instructions */
580 (format->fields, cache_rule->original_fields))
583 lf_printf (file, "%s %s;",
584 (cache_rule->type == NULL
586 : cache_rule->type), cache_rule->name);
587 lf_printf (file, " /*");
589 filter_next (cache_rule->original_fields, "");
592 filter_next (cache_rule->original_fields, memb))
594 lf_printf (file, " %s", memb);
596 lf_printf (file, " */\n");
599 /* define an entry for any fields not covered by a cache rule */
600 for (field = filter_next (format->fields, "");
601 field != NULL; field = filter_next (format->fields, field))
603 cache_entry *cache_rule;
605 for (cache_rule = cache_rules;
606 cache_rule != NULL; cache_rule = cache_rule->next)
608 if (strcmp (cache_rule->name, field) == 0)
615 lf_printf (file, "unsigned %s; /* default */\n", field);
618 lf_indent (file, -2);
619 lf_printf (file, "} %s;\n", format->name);
621 lf_indent (file, -2);
622 lf_printf (file, "} crack;\n");
624 lf_indent (file, -2);
625 lf_printf (file, "} %sidecode_cache;\n",
626 options.module.global.prefix.l);
630 /* alernativly, since no cache, emit a dummy definition for
631 idecode_cache so that code refering to the type can still compile */
632 lf_printf (file, "typedef void %sidecode_cache;\n",
633 options.module.global.prefix.l);
635 lf_printf (file, "\n");
641 print_icache_function (lf *file,
642 insn_entry * instruction,
643 opcode_bits *expanded_bits,
644 insn_opcodes *opcodes,
645 cache_entry *cache_rules, int nr_prefetched_words)
649 /* generate code to enter decoded instruction into the icache */
650 lf_printf (file, "\n");
651 lf_print__function_type_function (file, print_icache_function_type,
652 "EXTERN_ICACHE", "\n");
653 indent = print_function_name (file,
655 instruction->format_name,
657 expanded_bits, function_name_prefix_icache);
658 indent += lf_printf (file, " ");
659 lf_indent (file, +indent);
660 lf_printf (file, "(");
661 print_icache_function_formal (file, nr_prefetched_words);
662 lf_printf (file, ")\n");
663 lf_indent (file, -indent);
665 /* function header */
666 lf_printf (file, "{\n");
667 lf_indent (file, +2);
669 print_my_defines (file,
671 instruction->format_name, expanded_bits);
672 print_itrace (file, instruction, 1 /*putting-value-in-cache */ );
674 print_idecode_validate (file, instruction, opcodes);
676 lf_printf (file, "\n");
677 lf_printf (file, "{\n");
678 lf_indent (file, +2);
679 if (options.gen.semantic_icache)
680 lf_printf (file, "unsigned_word nia;\n");
681 print_icache_body (file,
685 (options.gen.direct_access
687 : declare_variables),
688 (options.gen.semantic_icache
689 ? both_values_and_icache
690 : put_values_in_icache), nr_prefetched_words);
692 lf_printf (file, "\n");
693 lf_printf (file, "cache_entry->address = cia;\n");
694 lf_printf (file, "cache_entry->semantic = ");
695 print_function_name (file,
697 instruction->format_name,
698 NULL, expanded_bits, function_name_prefix_semantics);
699 lf_printf (file, ";\n");
700 lf_printf (file, "\n");
702 if (options.gen.semantic_icache)
704 lf_printf (file, "/* semantic routine */\n");
705 print_semantic_body (file, instruction, expanded_bits, opcodes);
706 lf_printf (file, "return nia;\n");
709 if (!options.gen.semantic_icache)
711 lf_printf (file, "/* return the function proper */\n");
712 lf_printf (file, "return ");
713 print_function_name (file,
715 instruction->format_name,
717 expanded_bits, function_name_prefix_semantics);
718 lf_printf (file, ";\n");
721 if (options.gen.direct_access)
723 print_icache_body (file,
728 (options.gen.semantic_icache
729 ? both_values_and_icache
730 : put_values_in_icache), nr_prefetched_words);
733 lf_indent (file, -2);
734 lf_printf (file, "}\n");
735 lf_indent (file, -2);
736 lf_printf (file, "}\n");
741 print_icache_definition (lf *file,
743 opcode_bits *expanded_bits,
744 insn_opcodes *opcodes,
745 cache_entry *cache_rules, int nr_prefetched_words)
747 print_icache_function (file,
750 opcodes, cache_rules, nr_prefetched_words);
756 print_icache_internal_function_declaration (lf *file,
757 function_entry * function,
760 ASSERT (options.gen.icache);
761 if (function->is_internal)
763 lf_printf (file, "\n");
764 lf_print__function_type_function (file, print_icache_function_type,
765 "INLINE_ICACHE", "\n");
766 print_function_name (file,
768 NULL, NULL, NULL, function_name_prefix_icache);
769 lf_printf (file, "\n(");
770 print_icache_function_formal (file, 0);
771 lf_printf (file, ");\n");
777 print_icache_internal_function_definition (lf *file,
778 function_entry * function,
781 ASSERT (options.gen.icache);
782 if (function->is_internal)
784 lf_printf (file, "\n");
785 lf_print__function_type_function (file, print_icache_function_type,
786 "INLINE_ICACHE", "\n");
787 print_function_name (file,
789 NULL, NULL, NULL, function_name_prefix_icache);
790 lf_printf (file, "\n(");
791 print_icache_function_formal (file, 0);
792 lf_printf (file, ")\n");
793 lf_printf (file, "{\n");
794 lf_indent (file, +2);
795 lf_printf (file, "/* semantic routine */\n");
796 if (options.gen.semantic_icache)
798 lf_print__line_ref (file, function->code->line);
799 table_print_code (file, function->code);
801 "error (\"Internal function must longjump\\n\");\n");
802 lf_printf (file, "return 0;\n");
806 lf_printf (file, "return ");
807 print_function_name (file,
810 NULL, NULL, function_name_prefix_semantics);
811 lf_printf (file, ";\n");
814 lf_print__internal_ref (file);
815 lf_indent (file, -2);
816 lf_printf (file, "}\n");