OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [sim/] [igen/] [ld-decode.h] - Blame information for rev 841

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* The IGEN simulator generator for GDB, the GNU Debugger.
2
 
3
   Copyright 2002, 2007, 2008, 2009, 2010 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);

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.