sim/igen/ld-insn.h

   1 /* The IGEN simulator generator for GDB, the GNU Debugger.
   2
   3    Copyright 2002-2023 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 uint64_t 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, const function_entry *function, void *data);
 223
 224 extern void function_entry_traverse
 225   (lf *file,
 226    const function_entry *functions,
 227    function_entry_handler * handler, void *data);
 228
 229
 230 /* cache-macro:
 231
 232    <cache-macro> ::=
 233        ":" <macro-type>
 234        ":" <filter-flags>
 235        ":" <filter-models>
 236        ":" <typedef>
 237        ":" <name>
 238        ":" <field-name> { "," <field-name> }
 239        ":" <expression>
 240        <nl>
 241        ;
 242
 243    <cache-macro-type> ::=
 244        "scratch"
 245        | "cache"
 246        | "compute"
 247        ;
 248
 249    <name> ::=
 250        <ident>
 251        | <ident> "_is_" <integer>
 252        ;
 253
 254    A cache entry is defined (for an instruction) when all
 255    <field-name>s are present as named opcode fields within the
 256    instructions format.
 257
 258    SCRATCH and CACHE macros are defined during the cache fill stage
 259    while CACHE and COMPUTE macros are defined during the instruction
 260    execution stage.
 261
 262    */
 263
 264 enum
 265 {
 266   cache_typedef_field = 4,
 267   cache_name_field,
 268   cache_original_fields_field,
 269   cache_expression_field,
 270   nr_cache_fields,
 271 };
 272
 273 typedef enum
 274 {
 275   scratch_value,
 276   cache_value,
 277   compute_value,
 278 }
 279 cache_entry_type;
 280
 281 typedef struct _cache_entry cache_entry;
 282 struct _cache_entry
 283 {
 284   line_ref *line;
 285   filter *flags;
 286   filter *models;
 287   cache_entry_type entry_type;
 288   char *name;
 289   filter *original_fields;
 290   char *type;
 291   char *expression;
 292   cache_entry *next;
 293 };
 294
 295
 296
 297 /* Model specs:
 298
 299    <model-processor> ::=
 300        ":" "model"
 301        ":" <filter-flags>
 302        ":" <filter-models>
 303        ":" <processor>
 304        ":" <BFD-processor>
 305        ":" <function-unit-data>
 306        <nl>
 307        ;
 308
 309    <model-macro> ::=
 310        ":" "model-macro"
 311        ":" <filter-flags>
 312        ":" <filter-models>
 313        <nl>
 314        <code-block>
 315        ;
 316
 317    <model-data> ::=
 318        ":" "model-data"
 319        ":" <filter-flags>
 320        ":" <filter-models>
 321        <nl>
 322        <code-block>
 323        ;
 324
 325    <model-static> ::=
 326        ":" "model-static"
 327        <function-spec>
 328        ;
 329
 330    <model-internal> ::=
 331        ":" "model-internal"
 332        <function-spec>
 333        ;
 334
 335    <model-function> ::=
 336        ":" "model-internal"
 337        <function-spec>
 338        ;
 339
 340  */
 341
 342 enum
 343 {
 344   nr_model_macro_fields = 4,
 345   nr_model_data_fields = 4,
 346   nr_model_static_fields = nr_function_fields,
 347   nr_model_internal_fields = nr_function_fields,
 348   nr_model_function_fields = nr_function_fields,
 349 };
 350
 351 typedef struct _model_data model_data;
 352 struct _model_data
 353 {
 354   line_ref *line;
 355   filter *flags;
 356   table_entry *entry;
 357   table_entry *code;
 358   model_data *next;
 359 };
 360
 361 enum
 362 {
 363   model_name_field = 4,
 364   model_full_name_field,
 365   model_unit_data_field,
 366   nr_model_processor_fields,
 367 };
 368
 369 typedef struct _model_entry model_entry;
 370 struct _model_entry
 371 {
 372   line_ref *line;
 373   filter *flags;
 374   char *name;
 375   char *full_name;
 376   char *unit_data;
 377   model_entry *next;
 378 };
 379
 380
 381 typedef struct _model_table model_table;
 382 struct _model_table
 383 {
 384   filter *processors;
 385   int nr_models;
 386   model_entry *models;
 387   model_data *macros;
 388   model_data *data;
 389   function_entry *statics;
 390   function_entry *internals;
 391   function_entry *functions;
 392 };
 393
 394
 395
 396 /* Instruction format:
 397
 398    An instruction is composed of a sequence of N bit instruction
 399    words.  Each word broken into a number of instruction fields.
 400    Those fields being constant (ex. an opcode) or variable (register
 401    spec).
 402
 403    <insn-word> ::=
 404        <insn-field> { "," <insn-field> } ;
 405
 406    <insn-field> ::=
 407        ( <binary-value-implying-width>
 408        | <field-name-implying-width>
 409        | [ <start-or-width> "." ] <field>
 410        )
 411        { [ "!" | "=" ] [ <value> | <field-name> ] }
 412        ;
 413
 414    <field> ::=
 415          { "*" }+
 416        | { "/" }+
 417        | <field-name>
 418        | "0x" <hex-value>
 419        | "0b" <binary-value>
 420        | "0" <octal-value>
 421        | <integer-value> ;
 422
 423 */
 424
 425 typedef enum _insn_field_cond_type
 426 {
 427   insn_field_cond_value,
 428   insn_field_cond_field,
 429 }
 430 insn_field_cond_type;
 431 typedef enum _insn_field_cond_test
 432 {
 433   insn_field_cond_eq,
 434   insn_field_cond_ne,
 435 }
 436 insn_field_cond_test;
 437 typedef struct _insn_field_cond insn_field_cond;
 438 struct _insn_field_cond
 439 {
 440   insn_field_cond_type type;
 441   insn_field_cond_test test;
 442   insn_uint value;
 443   struct _insn_field_entry *field;
 444   char *string;
 445   insn_field_cond *next;
 446 };
 447
 448
 449 typedef enum _insn_field_type
 450 {
 451   insn_field_invalid,
 452   insn_field_int,
 453   insn_field_reserved,
 454   insn_field_wild,
 455   insn_field_string,
 456 }
 457 insn_field_type;
 458
 459 typedef struct _insn_field_entry insn_field_entry;
 460 struct _insn_field_entry
 461 {
 462   int first;
 463   int last;
 464   int width;
 465   int word_nr;
 466   insn_field_type type;
 467   insn_uint val_int;
 468   char *pos_string;
 469   char *val_string;
 470   insn_field_cond *conditions;
 471   insn_field_entry *next;
 472   insn_field_entry *prev;
 473 };
 474
 475 typedef struct _insn_bit_entry insn_bit_entry;
 476 struct _insn_bit_entry
 477 {
 478   int value;
 479   int mask;
 480   insn_field_entry *field;
 481 };
 482
 483
 484
 485
 486 typedef struct _insn_entry insn_entry;  /* forward */
 487
 488 typedef struct _insn_word_entry insn_word_entry;
 489 struct _insn_word_entry
 490 {
 491   /* list of sub-fields making up the instruction.  bit provides
 492      faster access to the field data for bit N.  */
 493   insn_field_entry *first;
 494   insn_field_entry *last;
 495   insn_bit_entry *bit[max_insn_bit_size];
 496   /* set of all the string fields */
 497   filter *field_names;
 498   /* For multi-word instructions, The Nth word (from zero). */
 499   insn_word_entry *next;
 500 };
 501
 502
 503
 504 /* Instruction model:
 505
 506    Provides scheduling and other data for the code modeling the
 507    instruction unit.
 508
 509    <insn-model> ::=
 510        "*" [ <processor-list> ]
 511        ":" [ <function-unit-data> ]
 512        <nl>
 513        ;
 514
 515    <processor-list> ::=
 516        <processor> { "," <processor>" }
 517        ;
 518
 519    If the <processor-list> is empty, the model is made the default for
 520    this instruction.
 521
 522    */
 523
 524 enum
 525 {
 526   insn_model_name_field = 0,
 527   insn_model_unit_data_field = 1,
 528   nr_insn_model_fields = 1,
 529 };
 530
 531 typedef struct _insn_model_entry insn_model_entry;
 532 struct _insn_model_entry
 533 {
 534   line_ref *line;
 535   insn_entry *insn;
 536   filter *names;
 537   char *full_name;
 538   char *unit_data;
 539   insn_model_entry *next;
 540 };
 541
 542
 543
 544 /* Instruction mnemonic:
 545
 546    List of assembler mnemonics for the instruction.
 547
 548    <insn-mnenonic> ::=
 549        "\"" <assembler-mnemonic> "\""
 550        [ ":" <conditional-expression> ]
 551        <nl>
 552        ;
 553
 554    An assembler mnemonic string has the syntax:
 555
 556    <assembler-mnemonic>  ::=
 557        ( [ "%" <format-spec> ] "<" <func> [ "#" <param-list> ] ">"
 558        | "%%"
 559        | <other-letter>
 560        )+
 561
 562     Where, for instance, the text is translated into a printf format
 563     and argument pair:
 564
 565        "<FUNC>"         : "%ld", (long) FUNC
 566        "%<FUNC>..."     : "%...", FUNC
 567        "%s<FUNC>"       : "%s", <%s>FUNC (SD_, FUNC)
 568        "%s<FUNC#P1,P2>" : "%s", <%s>FUNC (SD_, P1,P2)
 569        "%lx<FUNC>"      : "%lx", (unsigned long) FUNC
 570        "%08lx<FUNC>"    : "%08lx", (unsigned long) FUNC
 571
 572     And "<%s>FUNC" denotes a function declared using the "%s" record
 573     specifier.
 574
 575
 576
 577        ;
 578
 579    */
 580
 581 enum
 582 {
 583   insn_mnemonic_format_field = 0,
 584   insn_mnemonic_condition_field = 1,
 585   nr_insn_mnemonic_fields = 1,
 586 };
 587
 588 typedef struct _insn_mnemonic_entry insn_mnemonic_entry;
 589 struct _insn_mnemonic_entry
 590 {
 591   line_ref *line;
 592   insn_entry *insn;
 593   char *format;
 594   char *condition;
 595   insn_mnemonic_entry *next;
 596 };
 597
 598
 599
 600 /* Instruction:
 601
 602    <insn> ::=
 603        <insn-word> { "+" <insn-word> }
 604        ":" <format-name>
 605        ":" <filter-flags>
 606        ":" <options>
 607        ":" <name>
 608        <nl>
 609        { <insn-model> }
 610        { <insn-mnemonic> }
 611        <code-block>
 612
 613  */
 614
 615 enum
 616 {
 617   insn_word_field = 0,
 618   insn_format_name_field = 1,
 619   insn_filter_flags_field = 2,
 620   insn_options_field = 3,
 621   insn_name_field = 4,
 622   nr_insn_fields = 5,
 623 };
 624
 625
 626 /* typedef struct _insn_entry insn_entry; */
 627 struct _insn_entry
 628 {
 629   line_ref *line;
 630   filter *flags;                /* filtered by options.filters */
 631   char *format_name;
 632   filter *options;
 633   char *name;
 634   /* the words that make up the instruction. Word provides direct
 635      access to word N. Pseudo instructions can be identified by
 636      nr_words == 0. */
 637   int nr_words;
 638   insn_word_entry *words;
 639   insn_word_entry **word;
 640   /* a set of all the fields from all the words */
 641   filter *field_names;
 642   /* an array of processor models, missing models are NULL! */
 643   int nr_models;
 644   insn_model_entry *models;
 645   insn_model_entry **model;
 646   filter *processors;
 647   /* list of assember formats */
 648   int nr_mnemonics;
 649   insn_mnemonic_entry *mnemonics;
 650   /* code body */
 651   table_entry *code;
 652   insn_entry *next;
 653 };
 654
 655
 656 /* Instruction table:
 657
 658  */
 659
 660 typedef struct _insn_table insn_table;
 661 struct _insn_table
 662 {
 663   cache_entry *caches;
 664   int max_nr_words;
 665   int nr_insns;
 666   insn_entry *insns;
 667   function_entry *functions;
 668   insn_entry *illegal_insn;
 669   model_table *model;
 670   filter *options;
 671   filter *flags;
 672 };
 673
 674 extern insn_table *load_insn_table (const char *file_name, cache_entry *cache);
 675
 676 typedef void insn_entry_handler
 677   (lf *file, const insn_table *isa, const insn_entry *insn, void *data);
 678
 679 extern void insn_table_traverse_insn
 680   (lf *file, const insn_table *isa, insn_entry_handler *handler, void *data);
 681
 682
 683
 684 /* Printing */
 685
 686 extern void print_insn_words (lf *file, const insn_entry *insn);
 687
 688
 689
 690 /* Debugging */
 691
 692 void dump_insn_field
 693   (lf *file, const char *prefix, const insn_field_entry *field,
 694    const char *suffix);
 695
 696 void dump_insn_word_entry
 697   (lf *file, const char *prefix, const insn_word_entry *word,
 698    const char *suffix);
 699
 700 void dump_insn_entry
 701   (lf *file, const char *prefix, const insn_entry *insn, const char *suffix);
 702
 703 void dump_cache_entries
 704   (lf *file, const char *prefix, const cache_entry *entry, const char *suffix);
 705
 706 void dump_insn_table
 707   (lf *file, const char *prefix, const insn_table *isa, const char *suffix);