1 /* The IGEN simulator generator for GDB, the GNU Debugger. 2 3 Copyright 2002-2014 Free Software Foundation, Inc. 4 5 Contributed by Andrew Cagney. 6 7 This file is part of GDB. 8 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. 13 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. 18 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/>. */ 21 22 23 24 typedef unsigned64 insn_uint; 25 26 27 /* Common among most entries: 28 29 All non instruction records have the format: 30 31 <...> ::= 32 ":" <record-name> 33 ":" <filter-flags> 34 ":" <filter-models> 35 ":" ... 36 37 */ 38 39 enum 40 { 41 record_type_field = 1, 42 old_record_type_field = 2, 43 record_filter_flags_field = 2, 44 record_filter_models_field = 3, 45 }; 46 47 48 /* Include: 49 50 Include the specified file. 51 52 <include> ::= 53 ":" "include" 54 ":" <filter-flags> 55 ":" <filter-models> 56 ":" <filename> 57 <nl> 58 ; 59 60 */ 61 62 enum 63 { 64 include_filename_field = 4, 65 nr_include_fields, 66 }; 67 68 69 70 /* Options: 71 72 Valid options are: hi-bit-nr (default 0), insn-bit-size (default 73 32), insn-specifying-widths (default true), multi-sim (default false). 74 75 <option> ::= 76 ":" "option" 77 ":" <filter-flags> 78 ":" <filter-models> 79 ":" <option-name> 80 ":" <option-value> 81 <nl> 82 ; 83 84 <option-name> ::= 85 "insn-bit-size" 86 | "insn-specifying-widths" 87 | "hi-bit-nr" 88 | "flags-filter" 89 | "model-filter" 90 | "multi-sim" 91 | "format-names" 92 ; 93 94 <option-value> ::= 95 "true" 96 | "false" 97 | <integer> 98 | <list> 99 ; 100 101 102 These update the global options structure. */ 103 104 105 enum 106 { 107 option_name_field = 4, 108 option_value_field, 109 nr_option_fields, 110 }; 111 112 113 114 /* Macro definitions: 115 116 <insn-macro> ::= 117 ":" "define" 118 ":" <filter-flags> 119 ":" <filter-models> 120 ":" <name> 121 ":" <arg-list> 122 ":" <expression> 123 <nl> 124 ; 125 126 <arg-list> ::= 127 [ <name> { "," <arg-list> } ] 128 ; 129 130 */ 131 132 133 enum 134 { 135 macro_name_field = 4, 136 macro_args_field, 137 macro_expr_field, 138 nr_macro_fields, 139 }; 140 141 142 143 /* Functions and internal routins: 144 145 NB: <filter-models> and <function-models> are equivalent. 146 147 148 <function> ::= 149 ":" "function" 150 <function-spec> 151 ; 152 153 <internal> ::= 154 ":" "internal" 155 <function-spec> 156 ; 157 158 <format> ::= 159 ":" ( "%s" | ... ) 160 <function-spec> 161 ; 162 163 <function-model> ::= 164 "*" [ <processor-list> ] 165 ":" 166 <nl> 167 ; 168 169 <function-spec> ::= 170 ":" <filter-flags> 171 ":" <filter-models> 172 ":" <typedef> 173 ":" <name> 174 [ ":" <parameter-list> ] 175 <nl> 176 [ <function-model> ] 177 <code-block> 178 ; 179 180 */ 181 182 enum 183 { 184 function_typedef_field = 4, 185 function_name_field, 186 function_param_field, 187 nr_function_fields, 188 }; 189 190 enum 191 { 192 function_model_name_field = 0, 193 nr_function_model_fields = 1, 194 }; 195 196 enum 197 { 198 old_function_typedef_field = 0, 199 old_function_type_field = 2, 200 old_function_name_field = 4, 201 old_function_param_field = 5, 202 nr_old_function_fields = 5, /* parameter-list is optional */ 203 }; 204 205 206 typedef struct _function_entry function_entry; 207 struct _function_entry 208 { 209 line_ref *line; 210 filter *flags; 211 filter *models; 212 char *type; 213 char *name; 214 char *param; 215 table_entry *code; 216 int is_internal; 217 function_entry *next; 218 }; 219 220 221 typedef void function_entry_handler 222 (lf *file, function_entry * function, void *data); 223 224 extern void function_entry_traverse 225 (lf *file, 226 function_entry * functions, function_entry_handler * handler, void *data); 227 228 229 /* cache-macro: 230 231 <cache-macro> ::= 232 ":" <macro-type> 233 ":" <filter-flags> 234 ":" <filter-models> 235 ":" <typedef> 236 ":" <name> 237 ":" <field-name> { "," <field-name> } 238 ":" <expression> 239 <nl> 240 ; 241 242 <cache-macro-type> ::= 243 "scratch" 244 | "cache" 245 | "compute" 246 ; 247 248 <name> ::= 249 <ident> 250 | <ident> "_is_" <integer> 251 ; 252 253 A cache entry is defined (for an instruction) when all 254 <field-name>s are present as named opcode fields within the 255 instructions format. 256 257 SCRATCH and CACHE macros are defined during the cache fill stage 258 while CACHE and COMPUTE macros are defined during the instruction 259 execution stage. 260 261 */ 262 263 enum 264 { 265 cache_typedef_field = 4, 266 cache_name_field, 267 cache_original_fields_field, 268 cache_expression_field, 269 nr_cache_fields, 270 }; 271 272 typedef enum 273 { 274 scratch_value, 275 cache_value, 276 compute_value, 277 } 278 cache_entry_type; 279 280 typedef struct _cache_entry cache_entry; 281 struct _cache_entry 282 { 283 line_ref *line; 284 filter *flags; 285 filter *models; 286 cache_entry_type entry_type; 287 char *name; 288 filter *original_fields; 289 char *type; 290 char *expression; 291 cache_entry *next; 292 }; 293 294 295 296 /* Model specs: 297 298 <model-processor> ::= 299 ":" "model" 300 ":" <filter-flags> 301 ":" <filter-models> 302 ":" <processor> 303 ":" <BFD-processor> 304 ":" <function-unit-data> 305 <nl> 306 ; 307 308 <model-macro> ::= 309 ":" "model-macro" 310 ":" <filter-flags> 311 ":" <filter-models> 312 <nl> 313 <code-block> 314 ; 315 316 <model-data> ::= 317 ":" "model-data" 318 ":" <filter-flags> 319 ":" <filter-models> 320 <nl> 321 <code-block> 322 ; 323 324 <model-static> ::= 325 ":" "model-static" 326 <function-spec> 327 ; 328 329 <model-internal> ::= 330 ":" "model-internal" 331 <function-spec> 332 ; 333 334 <model-function> ::= 335 ":" "model-internal" 336 <function-spec> 337 ; 338 339 */ 340 341 enum 342 { 343 nr_model_macro_fields = 4, 344 nr_model_data_fields = 4, 345 nr_model_static_fields = nr_function_fields, 346 nr_model_internal_fields = nr_function_fields, 347 nr_model_function_fields = nr_function_fields, 348 }; 349 350 typedef struct _model_data model_data; 351 struct _model_data 352 { 353 line_ref *line; 354 filter *flags; 355 table_entry *entry; 356 table_entry *code; 357 model_data *next; 358 }; 359 360 enum 361 { 362 model_name_field = 4, 363 model_full_name_field, 364 model_unit_data_field, 365 nr_model_processor_fields, 366 }; 367 368 typedef struct _model_entry model_entry; 369 struct _model_entry 370 { 371 line_ref *line; 372 filter *flags; 373 char *name; 374 char *full_name; 375 char *unit_data; 376 model_entry *next; 377 }; 378 379 380 typedef struct _model_table model_table; 381 struct _model_table 382 { 383 filter *processors; 384 int nr_models; 385 model_entry *models; 386 model_data *macros; 387 model_data *data; 388 function_entry *statics; 389 function_entry *internals; 390 function_entry *functions; 391 }; 392 393 394 395 /* Instruction format: 396 397 An instruction is composed of a sequence of N bit instruction 398 words. Each word broken into a number of instruction fields. 399 Those fields being constant (ex. an opcode) or variable (register 400 spec). 401 402 <insn-word> ::= 403 <insn-field> { "," <insn-field> } ; 404 405 <insn-field> ::= 406 ( <binary-value-implying-width> 407 | <field-name-implying-width> 408 | [ <start-or-width> "." ] <field> 409 ) 410 { [ "!" | "=" ] [ <value> | <field-name> ] } 411 ; 412 413 <field> ::= 414 { "*" }+ 415 | { "/" }+ 416 | <field-name> 417 | "0x" <hex-value> 418 | "0b" <binary-value> 419 | "0" <octal-value> 420 | <integer-value> ; 421 422 */ 423 424 typedef enum _insn_field_cond_type 425 { 426 insn_field_cond_value, 427 insn_field_cond_field, 428 } 429 insn_field_cond_type; 430 typedef enum _insn_field_cond_test 431 { 432 insn_field_cond_eq, 433 insn_field_cond_ne, 434 } 435 insn_field_cond_test; 436 typedef struct _insn_field_cond insn_field_cond; 437 struct _insn_field_cond 438 { 439 insn_field_cond_type type; 440 insn_field_cond_test test; 441 insn_uint value; 442 struct _insn_field_entry *field; 443 char *string; 444 insn_field_cond *next; 445 }; 446 447 448 typedef enum _insn_field_type 449 { 450 insn_field_invalid, 451 insn_field_int, 452 insn_field_reserved, 453 insn_field_wild, 454 insn_field_string, 455 } 456 insn_field_type; 457 458 typedef struct _insn_field_entry insn_field_entry; 459 struct _insn_field_entry 460 { 461 int first; 462 int last; 463 int width; 464 int word_nr; 465 insn_field_type type; 466 insn_uint val_int; 467 char *pos_string; 468 char *val_string; 469 insn_field_cond *conditions; 470 insn_field_entry *next; 471 insn_field_entry *prev; 472 }; 473 474 typedef struct _insn_bit_entry insn_bit_entry; 475 struct _insn_bit_entry 476 { 477 int value; 478 int mask; 479 insn_field_entry *field; 480 }; 481 482 483 484 485 typedef struct _insn_entry insn_entry; /* forward */ 486 487 typedef struct _insn_word_entry insn_word_entry; 488 struct _insn_word_entry 489 { 490 /* list of sub-fields making up the instruction. bit provides 491 faster access to the field data for bit N. */ 492 insn_field_entry *first; 493 insn_field_entry *last; 494 insn_bit_entry *bit[max_insn_bit_size]; 495 /* set of all the string fields */ 496 filter *field_names; 497 /* For multi-word instructions, The Nth word (from zero). */ 498 insn_word_entry *next; 499 }; 500 501 502 503 /* Instruction model: 504 505 Provides scheduling and other data for the code modeling the 506 instruction unit. 507 508 <insn-model> ::= 509 "*" [ <processor-list> ] 510 ":" [ <function-unit-data> ] 511 <nl> 512 ; 513 514 <processor-list> ::= 515 <processor> { "," <processor>" } 516 ; 517 518 If the <processor-list> is empty, the model is made the default for 519 this instruction. 520 521 */ 522 523 enum 524 { 525 insn_model_name_field = 0, 526 insn_model_unit_data_field = 1, 527 nr_insn_model_fields = 1, 528 }; 529 530 typedef struct _insn_model_entry insn_model_entry; 531 struct _insn_model_entry 532 { 533 line_ref *line; 534 insn_entry *insn; 535 filter *names; 536 char *full_name; 537 char *unit_data; 538 insn_model_entry *next; 539 }; 540 541 542 543 /* Instruction mnemonic: 544 545 List of assembler mnemonics for the instruction. 546 547 <insn-mnenonic> ::= 548 "\"" <assembler-mnemonic> "\"" 549 [ ":" <conditional-expression> ] 550 <nl> 551 ; 552 553 An assembler mnemonic string has the syntax: 554 555 <assembler-mnemonic> ::= 556 ( [ "%" <format-spec> ] "<" <func> [ "#" <param-list> ] ">" 557 | "%%" 558 | <other-letter> 559 )+ 560 561 Where, for instance, the text is translated into a printf format 562 and argument pair: 563 564 "<FUNC>" : "%ld", (long) FUNC 565 "%<FUNC>..." : "%...", FUNC 566 "%s<FUNC>" : "%s", <%s>FUNC (SD_, FUNC) 567 "%s<FUNC#P1,P2>" : "%s", <%s>FUNC (SD_, P1,P2) 568 "%lx<FUNC>" : "%lx", (unsigned long) FUNC 569 "%08lx<FUNC>" : "%08lx", (unsigned long) FUNC 570 571 And "<%s>FUNC" denotes a function declared using the "%s" record 572 specifier. 573 574 575 576 ; 577 578 */ 579 580 enum 581 { 582 insn_mnemonic_format_field = 0, 583 insn_mnemonic_condition_field = 1, 584 nr_insn_mnemonic_fields = 1, 585 }; 586 587 typedef struct _insn_mnemonic_entry insn_mnemonic_entry; 588 struct _insn_mnemonic_entry 589 { 590 line_ref *line; 591 insn_entry *insn; 592 char *format; 593 char *condition; 594 insn_mnemonic_entry *next; 595 }; 596 597 598 599 /* Instruction: 600 601 <insn> ::= 602 <insn-word> { "+" <insn-word> } 603 ":" <format-name> 604 ":" <filter-flags> 605 ":" <options> 606 ":" <name> 607 <nl> 608 { <insn-model> } 609 { <insn-mnemonic> } 610 <code-block> 611 612 */ 613 614 enum 615 { 616 insn_word_field = 0, 617 insn_format_name_field = 1, 618 insn_filter_flags_field = 2, 619 insn_options_field = 3, 620 insn_name_field = 4, 621 nr_insn_fields = 5, 622 }; 623 624 625 /* typedef struct _insn_entry insn_entry; */ 626 struct _insn_entry 627 { 628 line_ref *line; 629 filter *flags; /* filtered by options.filters */ 630 char *format_name; 631 filter *options; 632 char *name; 633 /* the words that make up the instruction. Word provides direct 634 access to word N. Pseudo instructions can be identified by 635 nr_words == 0. */ 636 int nr_words; 637 insn_word_entry *words; 638 insn_word_entry **word; 639 /* a set of all the fields from all the words */ 640 filter *field_names; 641 /* an array of processor models, missing models are NULL! */ 642 int nr_models; 643 insn_model_entry *models; 644 insn_model_entry **model; 645 filter *processors; 646 /* list of assember formats */ 647 int nr_mnemonics; 648 insn_mnemonic_entry *mnemonics; 649 /* code body */ 650 table_entry *code; 651 insn_entry *next; 652 }; 653 654 655 /* Instruction table: 656 657 */ 658 659 typedef struct _insn_table insn_table; 660 struct _insn_table 661 { 662 cache_entry *caches; 663 int max_nr_words; 664 int nr_insns; 665 insn_entry *insns; 666 function_entry *functions; 667 insn_entry *illegal_insn; 668 model_table *model; 669 filter *options; 670 filter *flags; 671 }; 672 673 extern insn_table *load_insn_table (char *file_name, cache_entry *cache); 674 675 typedef void insn_entry_handler 676 (lf *file, insn_table *isa, insn_entry * insn, void *data); 677 678 extern void insn_table_traverse_insn 679 (lf *file, insn_table *isa, insn_entry_handler * handler, void *data); 680 681 682 683 /* Printing */ 684 685 extern void print_insn_words (lf *file, insn_entry * insn); 686 687 688 689 /* Debugging */ 690 691 void 692 dump_insn_field 693 (lf *file, char *prefix, insn_field_entry *field, char *suffix); 694 695 void 696 dump_insn_word_entry 697 (lf *file, char *prefix, insn_word_entry *word, char *suffix); 698 699 void 700 dump_insn_entry (lf *file, char *prefix, insn_entry * insn, char *suffix); 701 702 void 703 dump_cache_entries 704 (lf *file, char *prefix, cache_entry *entry, char *suffix); 705 706 void dump_insn_table (lf *file, char *prefix, insn_table *isa, char *suffix); 707