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.
26 #include "ld-decode.h"
33 update_depth(insn_table
*entry
,
39 int *max_depth
= (int*)data
;
40 if (*max_depth
< depth
)
46 insn_table_depth(insn_table
*table
)
49 insn_table_traverse_tree(table
,
62 parse_insn_format(table_entry
*entry
,
66 insn_fields
*fields
= ZALLOC(insn_fields
);
68 /* create a leading sentinal */
69 fields
->first
= ZALLOC(insn_field
);
70 fields
->first
->first
= -1;
71 fields
->first
->last
= -1;
72 fields
->first
->width
= 0;
74 /* and a trailing sentinal */
75 fields
->last
= ZALLOC(insn_field
);
76 fields
->last
->first
= insn_bit_size
;
77 fields
->last
->last
= insn_bit_size
;
78 fields
->last
->width
= 0;
80 /* link them together */
81 fields
->first
->next
= fields
->last
;
82 fields
->last
->prev
= fields
->first
;
84 /* now work through the formats */
87 while (*chp
!= '\0') {
92 insn_field
*new_field
;
94 /* skip leading spaces */
95 while (isspace(*chp
) && *chp
!= '\n')
98 /* break out the first field (if present) */
106 strlen_pos
= chp
- start_pos
;
108 /* break out the second field (if present) */
110 /* assume that the value length specifies the nr of bits */
111 start_val
= start_pos
;
112 strlen_val
= strlen_pos
;
119 if (*chp
== '/' || *chp
== '*') {
122 } while (*chp
== '/' || *chp
== '*');
124 else if (isalpha(*start_val
)) {
127 } while (isalnum(*chp
) || *chp
== '_');
129 else if (isdigit(*start_val
)) {
132 } while (isalnum(*chp
));
134 strlen_val
= chp
- start_val
;
137 /* skip trailing spaces */
138 while (isspace(*chp
))
141 /* verify field finished */
144 else if (*chp
!= '\0' || strlen_val
== 0) {
145 error("%s:%d: missing field terminator at %s\n",
146 entry
->file_name
, entry
->line_nr
, chp
);
150 /* create a new field and insert it */
151 new_field
= ZALLOC(insn_field
);
152 new_field
->next
= fields
->last
;
153 new_field
->prev
= fields
->last
->prev
;
154 new_field
->next
->prev
= new_field
;
155 new_field
->prev
->next
= new_field
;
158 new_field
->val_string
= (char*)zalloc(strlen_val
+1);
159 strncpy(new_field
->val_string
, start_val
, strlen_val
);
160 if (isdigit(new_field
->val_string
[0])) {
161 if (strlen_pos
== 0) {
164 for (i
= 0; i
< strlen_val
; i
++) {
165 if (start_val
[i
] != '0' && start_val
[i
] != '1')
166 error("%s:%d: invalid binary field %s\n",
167 entry
->file_name
, entry
->line_nr
, start_val
);
168 val
= (val
<< 1) + (start_val
[i
] == '1');
170 new_field
->val_int
= val
;
171 new_field
->is_int
= 1;
174 new_field
->val_int
= a2i(new_field
->val_string
);
175 new_field
->is_int
= 1;
178 else if (new_field
->val_string
[0] == '/'
179 || new_field
->val_string
[0] == '*') {
180 new_field
->is_slash
= 1;
183 new_field
->is_string
= 1;
187 new_field
->pos_string
= (char*)zalloc(strlen_pos
+1);
188 strncpy(new_field
->pos_string
, start_pos
, strlen_pos
);
189 if (strlen_pos
== 0) {
190 new_field
->first
= new_field
->prev
->last
+ 1;
191 new_field
->width
= strlen_val
;
192 new_field
->last
= new_field
->first
+ new_field
->width
- 1;
193 if (new_field
->last
>= insn_bit_size
)
194 error("%s:%d: Bit position %d exceed instruction bit size (%d)",
195 entry
->file_name
, entry
->line_nr
,
196 new_field
->last
, insn_bit_size
);
198 else if (insn_specifying_widths
) {
199 new_field
->first
= new_field
->prev
->last
+ 1;
200 new_field
->width
= a2i(new_field
->pos_string
);
201 new_field
->last
= new_field
->first
+ new_field
->width
- 1;
202 if (new_field
->last
>= insn_bit_size
)
203 error("%s:%d: Bit position %d exceed instruction bit size (%d)",
204 entry
->file_name
, entry
->line_nr
,
205 new_field
->last
, insn_bit_size
);
208 new_field
->first
= target_a2i(hi_bit_nr
, new_field
->pos_string
);
209 new_field
->last
= new_field
->next
->first
- 1; /* guess */
210 new_field
->width
= new_field
->last
- new_field
->first
+ 1; /* guess */
211 new_field
->prev
->last
= new_field
->first
- 1; /*fix*/
212 new_field
->prev
->width
= new_field
->first
- new_field
->prev
->first
; /*fix*/
216 /* fiddle first/last so that the sentinals `disapear' */
217 ASSERT(fields
->first
->last
< 0);
218 ASSERT(fields
->last
->first
>= insn_bit_size
);
219 fields
->first
= fields
->first
->next
;
220 fields
->last
= fields
->last
->prev
;
222 /* now go over this again, pointing each bit position at a field
227 field
= fields
->first
;
228 for (i
= 0; i
< insn_bit_size
; i
++) {
229 while (field
->last
< i
)
231 fields
->bits
[i
] = field
;
235 /* go over each of the fields, and compute a `value' for the insn */
239 for (field
= fields
->first
;
240 field
->last
< insn_bit_size
;
241 field
= field
->next
) {
242 fields
->value
<<= field
->width
;
244 fields
->value
|= field
->val_int
;
252 model_table_insert(insn_table
*table
,
253 table_entry
*file_entry
)
257 /* create a new model */
258 model
*new_model
= ZALLOC(model
);
260 new_model
->name
= file_entry
->fields
[model_identifer
];
261 new_model
->printable_name
= file_entry
->fields
[model_name
];
262 new_model
->insn_default
= file_entry
->fields
[model_default
];
264 while (*new_model
->insn_default
&& isspace(*new_model
->insn_default
))
265 new_model
->insn_default
++;
267 len
= strlen(new_model
->insn_default
);
268 if (max_model_fields_len
< len
)
269 max_model_fields_len
= len
;
271 /* append it to the end of the model list */
273 last_model
->next
= new_model
;
276 last_model
= new_model
;
280 model_table_insert_specific(insn_table
*table
,
281 table_entry
*file_entry
,
285 insn
*ptr
= ZALLOC(insn
);
286 ptr
->file_entry
= file_entry
;
288 (*end_ptr
)->next
= ptr
;
296 insn_table_insert_function(insn_table
*table
,
297 table_entry
*file_entry
)
299 /* create a new function */
300 insn
*new_function
= ZALLOC(insn
);
301 new_function
->file_entry
= file_entry
;
303 /* append it to the end of the function list */
304 if (table
->last_function
)
305 table
->last_function
->next
= new_function
;
307 table
->functions
= new_function
;
308 table
->last_function
= new_function
;
312 insn_table_insert_insn(insn_table
*table
,
313 table_entry
*file_entry
,
316 insn
**ptr_to_cur_insn
= &table
->insns
;
317 insn
*cur_insn
= *ptr_to_cur_insn
;
318 table_model_entry
*insn_model_ptr
;
321 /* create a new instruction */
322 insn
*new_insn
= ZALLOC(insn
);
323 new_insn
->file_entry
= file_entry
;
324 new_insn
->fields
= fields
;
326 /* Check out any model information returned to make sure the model
328 for(insn_model_ptr
= file_entry
->model_first
; insn_model_ptr
; insn_model_ptr
= insn_model_ptr
->next
) {
329 char *name
= insn_model_ptr
->fields
[insn_model_name
];
330 int len
= strlen (insn_model_ptr
->fields
[insn_model_fields
]);
332 while (len
> 0 && isspace(*insn_model_ptr
->fields
[insn_model_fields
])) {
334 insn_model_ptr
->fields
[insn_model_fields
]++;
337 if (max_model_fields_len
< len
)
338 max_model_fields_len
= len
;
340 for(model_ptr
= models
; model_ptr
; model_ptr
= model_ptr
->next
) {
341 if (strcmp(name
, model_ptr
->printable_name
) == 0) {
343 /* Replace the name field with that of the global model, so that when we
344 want to print it out, we can just compare pointers. */
345 insn_model_ptr
->fields
[insn_model_name
] = model_ptr
->printable_name
;
351 error("%s:%d: machine model `%s' was not known about\n",
352 file_entry
->file_name
, file_entry
->line_nr
, name
);
355 /* insert it according to the order of the fields */
356 while (cur_insn
!= NULL
357 && new_insn
->fields
->value
>= cur_insn
->fields
->value
) {
358 ptr_to_cur_insn
= &cur_insn
->next
;
359 cur_insn
= *ptr_to_cur_insn
;
362 new_insn
->next
= cur_insn
;
363 *ptr_to_cur_insn
= new_insn
;
371 load_insn_table(const char *file_name
,
372 decode_table
*decode_rules
,
375 table
*file
= table_open(file_name
, nr_insn_table_fields
, nr_insn_model_table_fields
);
376 insn_table
*table
= ZALLOC(insn_table
);
377 table_entry
*file_entry
;
378 table
->opcode_rule
= decode_rules
;
380 while ((file_entry
= table_entry_read(file
)) != NULL
) {
381 if (it_is("function", file_entry
->fields
[insn_flags
])
382 || it_is("internal", file_entry
->fields
[insn_flags
])) {
383 insn_table_insert_function(table
, file_entry
);
385 else if (it_is("model", file_entry
->fields
[insn_flags
])) {
386 model_table_insert(table
, file_entry
);
388 else if (it_is("model-macro", file_entry
->fields
[insn_flags
])) {
389 model_table_insert_specific(table
, file_entry
, &model_macros
, &last_model_macro
);
391 else if (it_is("model-function", file_entry
->fields
[insn_flags
])) {
392 model_table_insert_specific(table
, file_entry
, &model_functions
, &last_model_function
);
394 else if (it_is("model-internal", file_entry
->fields
[insn_flags
])) {
395 model_table_insert_specific(table
, file_entry
, &model_internal
, &last_model_internal
);
397 else if (it_is("model-static", file_entry
->fields
[insn_flags
])) {
398 model_table_insert_specific(table
, file_entry
, &model_static
, &last_model_static
);
400 else if (it_is("model-data", file_entry
->fields
[insn_flags
])) {
401 model_table_insert_specific(table
, file_entry
, &model_data
, &last_model_data
);
405 /* skip instructions that aren't relevant to the mode */
406 if (is_filtered_out(file_entry
->fields
[insn_flags
], filters
)) {
407 fprintf(stderr
, "Dropping %s - %s\n",
408 file_entry
->fields
[insn_name
],
409 file_entry
->fields
[insn_flags
]);
412 /* create/insert the new instruction */
413 fields
= parse_insn_format(file_entry
,
414 file_entry
->fields
[insn_format
]);
415 insn_table_insert_insn(table
, file_entry
, fields
);
424 insn_table_traverse_tree(insn_table
*table
,
431 padding_handler
*padding
)
437 && table
->opcode
!= NULL
438 && table
->nr_entries
> 0
439 && table
->entries
!= 0);
441 if (start
!= NULL
&& depth
>= 0)
442 start(table
, file
, data
, depth
);
444 for (entry_nr
= 0, entry
= table
->entries
;
445 entry_nr
< (table
->opcode
->is_boolean
447 : (1 << (table
->opcode
->last
- table
->opcode
->first
+ 1)));
450 || (!table
->opcode
->is_boolean
451 && entry_nr
< entry
->opcode_nr
)) {
452 if (padding
!= NULL
&& depth
>= 0)
453 padding(table
, file
, data
, depth
, entry_nr
);
456 ASSERT(entry
!= NULL
&& (entry
->opcode_nr
== entry_nr
457 || table
->opcode
->is_boolean
));
458 if (entry
->opcode
!= NULL
&& depth
!= 0) {
459 insn_table_traverse_tree(entry
, file
, data
, depth
+1,
460 start
, leaf
, end
, padding
);
462 else if (depth
>= 0) {
464 leaf(entry
, file
, data
, entry
->insns
, depth
);
466 entry
= entry
->sibling
;
469 if (end
!= NULL
&& depth
>= 0)
470 end(table
, file
, data
, depth
);
475 insn_table_traverse_function(insn_table
*table
,
478 function_handler
*leaf
)
481 for (function
= table
->functions
;
483 function
= function
->next
) {
484 leaf(table
, file
, data
, function
->file_entry
);
489 insn_table_traverse_insn(insn_table
*table
,
492 insn_handler
*handler
)
495 for (instruction
= table
->insns
;
497 instruction
= instruction
->next
) {
498 handler(table
, file
, data
, instruction
, 0);
503 /****************************************************************/
506 field_constant_int
= 1,
507 field_constant_slash
= 2,
508 field_constant_string
= 3
509 } constant_field_types
;
513 insn_field_is_constant(insn_field
*field
,
516 /* field is an integer */
518 return field_constant_int
;
519 /* field is `/' and treating that as a constant */
520 if (field
->is_slash
&& rule
->force_slash
)
521 return field_constant_slash
;
522 /* field, though variable is on the list */
523 if (field
->is_string
&& rule
->force_expansion
!= NULL
) {
524 char *forced_fields
= rule
->force_expansion
;
525 while (*forced_fields
!= '\0') {
527 char *end
= strchr(forced_fields
, ',');
529 field_len
= strlen(forced_fields
);
531 field_len
= end
-forced_fields
;
532 if (strncmp(forced_fields
, field
->val_string
, field_len
) == 0
533 && field
->val_string
[field_len
] == '\0')
534 return field_constant_string
;
535 forced_fields
+= field_len
;
536 if (*forced_fields
== ',')
544 static opcode_field
*
545 insn_table_find_opcode_field(insn
*insns
,
549 opcode_field
*curr_opcode
= ZALLOC(opcode_field
);
553 curr_opcode
->first
= insn_bit_size
;
554 curr_opcode
->last
= -1;
555 for (entry
= insns
; entry
!= NULL
; entry
= entry
->next
) {
556 insn_fields
*fields
= entry
->fields
;
557 opcode_field new_opcode
;
559 /* find a start point for the opcode field */
560 new_opcode
.first
= rule
->first
;
561 while (new_opcode
.first
<= rule
->last
563 || insn_field_is_constant(fields
->bits
[new_opcode
.first
],
564 rule
) != field_constant_string
)
566 || !insn_field_is_constant(fields
->bits
[new_opcode
.first
],
568 new_opcode
.first
= fields
->bits
[new_opcode
.first
]->last
+ 1;
569 ASSERT(new_opcode
.first
> rule
->last
571 && insn_field_is_constant(fields
->bits
[new_opcode
.first
],
572 rule
) == field_constant_string
)
574 && insn_field_is_constant(fields
->bits
[new_opcode
.first
],
577 /* find the end point for the opcode field */
578 new_opcode
.last
= rule
->last
;
579 while (new_opcode
.last
>= rule
->first
581 || insn_field_is_constant(fields
->bits
[new_opcode
.last
],
582 rule
) != field_constant_string
)
584 || !insn_field_is_constant(fields
->bits
[new_opcode
.last
],
586 new_opcode
.last
= fields
->bits
[new_opcode
.last
]->first
- 1;
587 ASSERT(new_opcode
.last
< rule
->first
589 && insn_field_is_constant(fields
->bits
[new_opcode
.last
],
590 rule
) == field_constant_string
)
592 && insn_field_is_constant(fields
->bits
[new_opcode
.last
],
595 /* now see if our current opcode needs expanding */
596 if (new_opcode
.first
<= rule
->last
597 && curr_opcode
->first
> new_opcode
.first
)
598 curr_opcode
->first
= new_opcode
.first
;
599 if (new_opcode
.last
>= rule
->first
600 && curr_opcode
->last
< new_opcode
.last
)
601 curr_opcode
->last
= new_opcode
.last
;
605 /* was any thing interesting found? */
606 if (curr_opcode
->first
> rule
->last
) {
607 ASSERT(curr_opcode
->last
< rule
->first
);
610 ASSERT(curr_opcode
->last
>= rule
->first
);
611 ASSERT(curr_opcode
->first
<= rule
->last
);
613 /* if something was found, check it includes the forced field range */
615 && curr_opcode
->first
> rule
->force_first
) {
616 curr_opcode
->first
= rule
->force_first
;
619 && curr_opcode
->last
< rule
->force_last
) {
620 curr_opcode
->last
= rule
->force_last
;
622 /* handle special case elminating any need to do shift after mask */
624 && rule
->force_last
== insn_bit_size
-1) {
625 curr_opcode
->last
= insn_bit_size
-1;
628 /* handle any special cases */
629 switch (rule
->type
) {
630 case normal_decode_rule
:
631 /* let the above apply */
633 case expand_forced_rule
:
634 /* expand a limited nr of bits, ignoring the rest */
635 curr_opcode
->first
= rule
->force_first
;
636 curr_opcode
->last
= rule
->force_last
;
639 curr_opcode
->is_boolean
= 1;
640 curr_opcode
->boolean_constant
= rule
->special_constant
;
643 error("Something is going wrong\n");
651 insn_table_insert_expanded(insn_table
*table
,
656 insn_table
**ptr_to_cur_entry
= &table
->entries
;
657 insn_table
*cur_entry
= *ptr_to_cur_entry
;
659 /* find the new table for this entry */
660 while (cur_entry
!= NULL
661 && cur_entry
->opcode_nr
< new_opcode_nr
) {
662 ptr_to_cur_entry
= &cur_entry
->sibling
;
663 cur_entry
= *ptr_to_cur_entry
;
666 if (cur_entry
== NULL
|| cur_entry
->opcode_nr
!= new_opcode_nr
) {
667 insn_table
*new_entry
= ZALLOC(insn_table
);
668 new_entry
->opcode_nr
= new_opcode_nr
;
669 new_entry
->expanded_bits
= new_bits
;
670 new_entry
->opcode_rule
= table
->opcode_rule
->next
;
671 new_entry
->sibling
= cur_entry
;
672 new_entry
->parent
= table
;
673 *ptr_to_cur_entry
= new_entry
;
674 cur_entry
= new_entry
;
677 /* ASSERT new_bits == cur_entry bits */
678 ASSERT(cur_entry
!= NULL
&& cur_entry
->opcode_nr
== new_opcode_nr
);
679 insn_table_insert_insn(cur_entry
,
680 old_insn
->file_entry
,
685 insn_table_expand_opcode(insn_table
*table
,
692 if (field_nr
> table
->opcode
->last
) {
693 insn_table_insert_expanded(table
, instruction
, opcode_nr
, bits
);
696 insn_field
*field
= instruction
->fields
->bits
[field_nr
];
697 if (field
->is_int
|| field
->is_slash
) {
698 if (!(field
->first
>= table
->opcode
->first
699 && field
->last
<= table
->opcode
->last
))
700 error("%s:%d: Instruction field %s.%s [%d..%d] overlaps sub-field [%d..%d] boundary",
701 instruction
->file_entry
->file_name
,
702 instruction
->file_entry
->line_nr
,
703 field
->pos_string
, field
->val_string
,
704 field
->first
, field
->last
,
705 table
->opcode
->first
, table
->opcode
->last
);
706 insn_table_expand_opcode(table
, instruction
, field
->last
+1,
707 ((opcode_nr
<< field
->width
) + field
->val_int
),
712 int last_pos
= ((field
->last
< table
->opcode
->last
)
713 ? field
->last
: table
->opcode
->last
);
714 int first_pos
= ((field
->first
> table
->opcode
->first
)
715 ? field
->first
: table
->opcode
->first
);
716 int width
= last_pos
- first_pos
+ 1;
717 int last_val
= (table
->opcode
->is_boolean
719 for (val
= 0; val
< last_val
; val
++) {
720 insn_bits
*new_bits
= ZALLOC(insn_bits
);
721 new_bits
->field
= field
;
722 new_bits
->value
= val
;
723 new_bits
->last
= bits
;
724 new_bits
->opcode
= table
->opcode
;
725 insn_table_expand_opcode(table
, instruction
, last_pos
+1,
726 ((opcode_nr
<< width
) | val
),
734 insn_table_insert_expanding(insn_table
*table
,
737 insn_table_expand_opcode(table
,
739 table
->opcode
->first
,
741 table
->expanded_bits
);
746 insn_table_expand_insns(insn_table
*table
)
749 ASSERT(table
->nr_insn
>= 1);
751 /* determine a valid opcode */
752 while (table
->opcode_rule
) {
753 /* specials only for single instructions */
754 if ((table
->nr_insn
> 1
755 && table
->opcode_rule
->special_mask
== 0
756 && table
->opcode_rule
->type
== normal_decode_rule
)
757 || (table
->nr_insn
== 1
758 && table
->opcode_rule
->special_mask
!= 0
759 && ((table
->insns
->fields
->value
760 & table
->opcode_rule
->special_mask
)
761 == table
->opcode_rule
->special_value
))
762 || (generate_expanded_instructions
763 && table
->opcode_rule
->special_mask
== 0
764 && table
->opcode_rule
->type
== normal_decode_rule
))
766 insn_table_find_opcode_field(table
->insns
,
768 table
->nr_insn
== 1/*string*/
770 if (table
->opcode
!= NULL
)
772 table
->opcode_rule
= table
->opcode_rule
->next
;
775 /* did we find anything */
776 if (table
->opcode
== NULL
) {
779 ASSERT(table
->opcode
!= NULL
);
781 /* back link what we found to its parent */
782 if (table
->parent
!= NULL
) {
783 ASSERT(table
->parent
->opcode
!= NULL
);
784 table
->opcode
->parent
= table
->parent
->opcode
;
787 /* expand the raw instructions according to the opcode */
790 for (entry
= table
->insns
; entry
!= NULL
; entry
= entry
->next
) {
791 insn_table_insert_expanding(table
, entry
);
795 /* and do the same for the sub entries */
798 for (entry
= table
->entries
; entry
!= NULL
; entry
= entry
->sibling
) {
799 insn_table_expand_insns(entry
);
810 dump_insn_field(insn_field
*field
,
814 printf("(insn_field*)0x%x\n", (unsigned)field
);
816 dumpf(indent
, "(first %d)\n", field
->first
);
818 dumpf(indent
, "(last %d)\n", field
->last
);
820 dumpf(indent
, "(width %d)\n", field
->width
);
823 dumpf(indent
, "(is_int %d)\n", field
->val_int
);
826 dumpf(indent
, "(is_slash)\n");
828 if (field
->is_string
)
829 dumpf(indent
, "(is_string `%s')\n", field
->val_string
);
831 dumpf(indent
, "(next 0x%x)\n", field
->next
);
833 dumpf(indent
, "(prev 0x%x)\n", field
->prev
);
839 dump_insn_fields(insn_fields
*fields
,
844 printf("(insn_fields*)%p\n", fields
);
846 dumpf(indent
, "(first 0x%x)\n", fields
->first
);
847 dumpf(indent
, "(last 0x%x)\n", fields
->last
);
849 dumpf(indent
, "(value 0x%x)\n", fields
->value
);
851 for (i
= 0; i
< insn_bit_size
; i
++) {
852 dumpf(indent
, "(bits[%d] ", i
, fields
->bits
[i
]);
853 dump_insn_field(fields
->bits
[i
], indent
+1);
854 dumpf(indent
, " )\n");
861 dump_opcode_field(opcode_field
*field
, int indent
, int levels
)
863 printf("(opcode_field*)%p\n", field
);
864 if (levels
&& field
!= NULL
) {
865 dumpf(indent
, "(first %d)\n", field
->first
);
866 dumpf(indent
, "(last %d)\n", field
->last
);
867 dumpf(indent
, "(is_boolean %d)\n", field
->is_boolean
);
868 dumpf(indent
, "(parent ");
869 dump_opcode_field(field
->parent
, indent
, levels
-1);
875 dump_insn_bits(insn_bits
*bits
, int indent
, int levels
)
877 printf("(insn_bits*)%p\n", bits
);
879 if (levels
&& bits
!= NULL
) {
880 dumpf(indent
, "(value %d)\n", bits
->value
);
881 dumpf(indent
, "(opcode ");
882 dump_opcode_field(bits
->opcode
, indent
+1, 0);
883 dumpf(indent
, " )\n");
884 dumpf(indent
, "(field ");
885 dump_insn_field(bits
->field
, indent
+1);
886 dumpf(indent
, " )\n");
887 dumpf(indent
, "(last ");
888 dump_insn_bits(bits
->last
, indent
+1, levels
-1);
895 dump_insn(insn
*entry
, int indent
, int levels
)
897 printf("(insn*)%p\n", entry
);
899 if (levels
&& entry
!= NULL
) {
901 dumpf(indent
, "(file_entry ");
902 dump_table_entry(entry
->file_entry
, indent
+1);
903 dumpf(indent
, " )\n");
905 dumpf(indent
, "(fields ");
906 dump_insn_fields(entry
->fields
, indent
+1);
907 dumpf(indent
, " )\n");
909 dumpf(indent
, "(next ");
910 dump_insn(entry
->next
, indent
+1, levels
-1);
911 dumpf(indent
, " )\n");
919 dump_insn_table(insn_table
*table
,
920 int indent
, int levels
)
923 printf("(insn_table*)%p\n", table
);
925 if (levels
&& table
!= NULL
) {
927 dumpf(indent
, "(opcode_nr %d)\n", table
->opcode_nr
);
929 dumpf(indent
, "(expanded_bits ");
930 dump_insn_bits(table
->expanded_bits
, indent
+1, -1);
931 dumpf(indent
, " )\n");
933 dumpf(indent
, "(int nr_insn %d)\n", table
->nr_insn
);
935 dumpf(indent
, "(insns ");
936 dump_insn(table
->insns
, indent
+1, table
->nr_insn
);
937 dumpf(indent
, " )\n");
939 dumpf(indent
, "(opcode_rule ");
940 dump_decode_rule(table
->opcode_rule
, indent
+1);
941 dumpf(indent
, " )\n");
943 dumpf(indent
, "(opcode ");
944 dump_opcode_field(table
->opcode
, indent
+1, 1);
945 dumpf(indent
, " )\n");
947 dumpf(indent
, "(nr_entries %d)\n", table
->entries
);
948 dumpf(indent
, "(entries ");
949 dump_insn_table(table
->entries
, indent
+1, table
->nr_entries
);
950 dumpf(indent
, " )\n");
952 dumpf(indent
, "(sibling ", table
->sibling
);
953 dump_insn_table(table
->sibling
, indent
+1, levels
-1);
954 dumpf(indent
, " )\n");
956 dumpf(indent
, "(parent ", table
->parent
);
957 dump_insn_table(table
->parent
, indent
+1, 0);
958 dumpf(indent
, " )\n");
963 int insn_bit_size
= default_insn_bit_size
;
965 int generate_expanded_instructions
;
966 int insn_specifying_widths
;
969 main(int argc
, char **argv
)
971 filter
*filters
= NULL
;
972 decode_table
*decode_rules
= NULL
;
973 insn_table
*instructions
= NULL
;
976 error("Usage: insn <filter-in> <hi-bit-nr> <insn-bit-size> <widths> <decode-table> <insn-table>\n");
978 filters
= new_filter(argv
[1], filters
);
979 hi_bit_nr
= a2i(argv
[2]);
980 insn_bit_size
= a2i(argv
[3]);
981 insn_specifying_widths
= a2i(argv
[4]);
982 ASSERT(hi_bit_nr
< insn_bit_size
);
983 decode_rules
= load_decode_table(argv
[5], hi_bit_nr
);
984 instructions
= load_insn_table(argv
[6], decode_rules
, filters
);
985 insn_table_expand_insns(instructions
);
987 dump_insn_table(instructions
, 0, -1);