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