1 /* The IGEN simulator generator for GDB, the GNU Debugger.
3 Copyright 2002, 2007, 2008, 2009 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");