sim/igen/ld-decode.h

   1 /* The IGEN simulator generator for GDB, the GNU Debugger.
   2
   3    Copyright 2002-2020 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 /* Instruction decode table:
  24
  25    <decode-rule> ::=
  26        { <option> }
  27        ":" [ <first> ]
  28        ":" [ <last> ]
  29        ":" [ <force-first> ]
  30        ":" [ <force-last> ]
  31        ":" [ <constant-field-names> ]
  32        ":" [ <word-nr> ]
  33        ":" [ <format-names> ]
  34        ":" [ <model-names> ]
  35        ":" [ <constant> ]
  36        ":" [ <path> { "," <path> } ]
  37        { ":" <special-mask>
  38          ":" [ "!" ] <special-value>
  39          ":" <word-nr> }
  40        <nl>
  41        ;
  42
  43
  44    <path> ::= <int> "," <int> ;;
  45
  46    <option> ::=
  47        <reserved-options>
  48        | <code-options>
  49        | <optimize-options>
  50        | <decode-options>
  51        | <constant>
  52        | <search-options>
  53        ;
  54
  55    <reserved-options> ::= "zero-reserved" ;
  56    <gen-options> ::= "array" | "switch" | "padded-switch" | "goto-switch" ;
  57    <optimize-options> ::= "duplicate" | "combine"
  58    <decode-options> ::= "normal" | "boolean" ;
  59    <search-options> ::= "constants" | "variables" | "mixed"
  60
  61    Ignore the below:
  62
  63
  64    The instruction decode table contains rules that dictate how igen
  65    is going to firstly break down the opcode table and secondly
  66
  67    The table that follows is used by gen to construct a decision tree
  68    that can identify each possible instruction.  Gen then outputs this
  69    decision tree as (according to config) a table or switch statement
  70    as the function idecode.
  71
  72    In parallel to this, as mentioned above, WITH_EXPANDED_SEMANTICS
  73    determines of the semantic functions themselves should be expanded
  74    in a similar way.
  75
  76    <first>
  77    <last>
  78
  79    Range of bits (within the instruction) that should be searched for
  80    an instruction field.  Within such ranges, gen looks for opcodes
  81    (constants), registers (strings) and reserved bits (slash) and
  82    according to the rules that follows includes or excludes them from
  83    a possible instruction field.
  84
  85    <force_first>
  86    <force_last>
  87
  88    If an instruction field was found, enlarge the field size so that
  89    it is forced to at least include bits starting from <force_first>
  90    (<force_last>).  To stop this occuring, use <force_first> = <last>
  91    + 1 and <force_last> = <first> - 1.
  92
  93    <force_reserved>
  94
  95    Treat `/' (reserved) fields as a constant (zero) instead of
  96    variable when looking for an instruction field.
  97
  98    <force_expansion>
  99
 100    Treat any contained register (string) fields as constant when
 101    determining the instruction field.  For the instruction decode (and
 102    controled by IDECODE_EXPAND_SEMANTICS) this forces the expansion of
 103    what would otherwize be non constant bits of an instruction.
 104
 105    <use_switch>
 106
 107    Should this table be expanded using a switch statement (val 1) and
 108    if so, should it be padded with entries so as to force the compiler
 109    to generate a jump table (val 2). Or a branch table (val 3).
 110
 111    <special_mask>
 112    <special_value>
 113    <special_rule>
 114    <special_constant>
 115
 116    Special rule to fine tune how specific (or groups) of instructions
 117    are expanded.  The applicability of the rule is determined by
 118
 119      <special_mask> != 0 && (instruction> & <special_mask>) == <special_value>
 120
 121    Where <instruction> is obtained by looking only at constant fields
 122    with in an instructions spec.  When determining an expansion, the
 123    rule is only considered when a node contains a single instruction.
 124    <special_rule> can be any of:
 125
 126         0: for this instruction, expand by earlier rules
 127         1: expand bits <force_low> .. <force_hi> only
 128         2: boolean expansion of only zero/non-zero cases
 129         3: boolean expansion of equality of special constant
 130
 131         */
 132
 133
 134 typedef enum
 135 {
 136   normal_decode_rule,
 137   boolean_rule,
 138 }
 139 decode_special_type;
 140
 141
 142 typedef enum
 143 {
 144   invalid_gen,
 145   array_gen,
 146   switch_gen,
 147   padded_switch_gen,
 148   goto_switch_gen,
 149 }
 150 decode_gen_type;
 151
 152
 153 enum
 154 {
 155   decode_cond_mask_field,
 156   decode_cond_value_field,
 157   decode_cond_word_nr_field,
 158   nr_decode_cond_fields,
 159 };
 160
 161 typedef struct _decode_path decode_path;
 162 struct _decode_path
 163 {
 164   int opcode_nr;
 165   decode_path *parent;
 166 };
 167
 168 typedef struct _decode_path_list decode_path_list;
 169 struct _decode_path_list
 170 {
 171   decode_path *path;
 172   decode_path_list *next;
 173 };
 174
 175
 176 typedef struct _decode_cond decode_cond;
 177 struct _decode_cond
 178 {
 179   int word_nr;
 180   int mask[max_insn_bit_size];
 181   int value[max_insn_bit_size];
 182   int is_equal;
 183   decode_cond *next;
 184 };
 185
 186 typedef enum
 187 {
 188   decode_find_mixed,
 189   decode_find_constants,
 190   decode_find_strings,
 191 }
 192 decode_search_type;
 193
 194 enum
 195 {
 196   decode_options_field,
 197   decode_first_field,
 198   decode_last_field,
 199   decode_force_first_field,
 200   decode_force_last_field,
 201   decode_constant_field_names_field,
 202   decode_word_nr_field,
 203   decode_format_names_field,
 204   decode_model_names_field,
 205   decode_paths_field,
 206   nr_decode_fields,
 207   min_nr_decode_fields = decode_last_field + 1,
 208 };
 209
 210
 211 typedef struct _decode_table decode_table;
 212 struct _decode_table
 213 {
 214   line_ref *line;
 215   decode_special_type type;
 216   decode_gen_type gen;
 217   decode_search_type search;
 218   int first;
 219   int last;
 220   int force_first;
 221   int force_last;
 222   filter *constant_field_names;
 223   int word_nr;
 224   /* if a boolean */
 225   unsigned constant;
 226   /* options */
 227   int with_zero_reserved;
 228   int with_duplicates;
 229   int with_combine;
 230   /* conditions on the rule being applied */
 231   decode_path_list *paths;
 232   filter *format_names;
 233   filter *model_names;
 234   decode_cond *conditions;
 235   decode_table *next;
 236 };
 237
 238
 239 extern decode_table *load_decode_table (char *file_name);
 240
 241 extern int decode_table_max_word_nr (decode_table *rule);
 242
 243 extern void dump_decode_rule
 244   (lf *file, char *prefix, decode_table *rule, char *suffix);