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 /* load the opcode stat structure */
24
25 #include "misc.h"
26 #include "lf.h"
27 #include "table.h"
28 #include "filter.h"
29
30 #include "igen.h"
31
32 #include "ld-decode.h"
33
34 #ifndef NULL
35 #define NULL 0
36 #endif
37
38
39 static const name_map decode_type_map[] = {
40 {"normal", normal_decode_rule},
41 {"boolean", boolean_rule},
42 {NULL, normal_decode_rule},
43 };
44
45 static const name_map decode_gen_map[] = {
46 {"array", array_gen},
47 {"switch", switch_gen},
48 {"padded-switch", padded_switch_gen},
49 {"goto-switch", goto_switch_gen},
50 {NULL, -1},
51 };
52
53 static const name_map decode_reserved_map[] = {
54 {"zero-reserved", 1},
55 {NULL, 0},
56 };
57
58 static const name_map decode_duplicates_map[] = {
59 {"duplicate", 1},
60 {NULL, 0},
61 };
62
63 static const name_map decode_combine_map[] = {
64 {"combine", 1},
65 {NULL, 0},
66 };
67
68 static const name_map decode_search_map[] = {
69 {"constants", decode_find_constants},
70 {"mixed", decode_find_mixed},
71 {"strings", decode_find_strings},
72 {NULL, decode_find_mixed},
73 };
74
75
76 static void
set_bits(int bit[max_insn_bit_size],unsigned64 value)77 set_bits (int bit[max_insn_bit_size], unsigned64 value)
78 {
79 int bit_nr;
80 for (bit_nr = 0; bit_nr < max_insn_bit_size; bit_nr++)
81 {
82 if (bit_nr < options.insn_bit_size)
83 bit[bit_nr] = (value >> (options.insn_bit_size - bit_nr - 1)) & 1;
84 else
85 bit[bit_nr] = 0;
86 }
87 }
88
89 decode_table *
load_decode_table(char * file_name)90 load_decode_table (char *file_name)
91 {
92 table *file = table_open (file_name);
93 table_entry *entry;
94 decode_table *table = NULL;
95 decode_table **curr_rule = &table;
96 while ((entry = table_read (file)) != NULL)
97 {
98 char *decode_options = entry->field[decode_options_field];
99 decode_table *new_rule = ZALLOC (decode_table);
100 if (entry->nr_fields < min_nr_decode_fields)
101 error (entry->line, "Missing decode table fields\n");
102 new_rule->line = entry->line;
103
104 /* the options field */
105 new_rule->type = name2i (decode_options, decode_type_map);
106 if (options.decode.overriding_gen != NULL)
107 new_rule->gen =
108 name2i (options.decode.overriding_gen, decode_gen_map);
109 else
110 new_rule->gen = name2i (decode_options, decode_gen_map);
111 if (new_rule->gen == padded_switch_gen && options.decode.switch_as_goto)
112 new_rule->gen = goto_switch_gen;
113 if (options.decode.zero_reserved)
114 new_rule->with_zero_reserved = 1;
115 else
116 new_rule->with_zero_reserved =
117 name2i (decode_options, decode_reserved_map);
118 if (options.decode.duplicate)
119 new_rule->with_duplicates = 1;
120 else
121 new_rule->with_duplicates =
122 name2i (decode_options, decode_duplicates_map);
123 if (options.decode.combine)
124 new_rule->with_combine = 1;
125 else
126 new_rule->with_combine = name2i (decode_options, decode_combine_map);
127 if (new_rule->type == boolean_rule)
128 {
129 char *chp = decode_options;
130 while (*chp != '\0')
131 {
132 if (isdigit (*chp))
133 {
134 new_rule->constant = a2i (chp);
135 break;
136 }
137 chp = skip_to_separator (chp, ",");
138 chp = skip_spaces (chp);
139 }
140 }
141
142 /* First and last */
143 if (entry->nr_fields > decode_first_field
144 && strlen (entry->field[decode_first_field]) > 0)
145 {
146 new_rule->first = target_a2i (options.hi_bit_nr,
147 entry->field[decode_first_field]);
148 if (new_rule->first < 0 || new_rule->first >= options.insn_bit_size)
149 error (new_rule->line, "First field out of range\n");
150 }
151 else
152 new_rule->first = 0;
153 if (entry->nr_fields > decode_last_field
154 && strlen (entry->field[decode_last_field]) > 0)
155 {
156 new_rule->last = target_a2i (options.hi_bit_nr,
157 entry->field[decode_last_field]);
158 if (new_rule->last < 0 || new_rule->last >= options.insn_bit_size)
159 error (new_rule->line, "Last field out of range\n");
160 }
161 else
162 new_rule->last = options.insn_bit_size - 1;
163 if (new_rule->first > new_rule->last)
164 error (new_rule->line, "First must preceed last\n");
165
166 /* force first/last, with default values based on first/last */
167 if (entry->nr_fields > decode_force_first_field
168 && strlen (entry->field[decode_force_first_field]) > 0)
169 {
170 new_rule->force_first = target_a2i (options.hi_bit_nr,
171 entry->
172 field
173 [decode_force_first_field]);
174 if (new_rule->force_first < new_rule->first
175 || new_rule->force_first > new_rule->last + 1)
176 error (new_rule->line, "Force first out of range\n");
177 }
178 else
179 new_rule->force_first = new_rule->last + 1;
180 if (entry->nr_fields > decode_force_last_field
181 && strlen (entry->field[decode_force_last_field]) > 0)
182 {
183 new_rule->force_last = target_a2i (options.hi_bit_nr,
184 entry->
185 field[decode_force_last_field]);
186 if (new_rule->force_last > new_rule->last
187 || new_rule->force_last < new_rule->first - 1)
188 error (new_rule->line, "Force-last out of range\n");
189 }
190 else
191 new_rule->force_last = new_rule->first - 1;
192
193 /* fields to be treated as constant */
194 if (entry->nr_fields > decode_constant_field_names_field)
195 filter_parse (&new_rule->constant_field_names,
196 entry->field[decode_constant_field_names_field]);
197
198 /* applicable word nr */
199 if (entry->nr_fields > decode_word_nr_field)
200 new_rule->word_nr = a2i (entry->field[decode_word_nr_field]);
201
202 /* required instruction format names */
203 if (entry->nr_fields > decode_format_names_field)
204 filter_parse (&new_rule->format_names,
205 entry->field[decode_format_names_field]);
206
207 /* required processor models */
208 if (entry->nr_fields > decode_model_names_field)
209 filter_parse (&new_rule->model_names,
210 entry->field[decode_model_names_field]);
211
212 /* required paths */
213 if (entry->nr_fields > decode_paths_field
214 && strlen (entry->field[decode_paths_field]) > 0)
215 {
216 decode_path_list **last = &new_rule->paths;
217 char *chp = entry->field[decode_paths_field];
218 do
219 {
220 (*last) = ZALLOC (decode_path_list);
221 /* extra root/zero entry */
222 (*last)->path = ZALLOC (decode_path);
223 do
224 {
225 decode_path *entry = ZALLOC (decode_path);
226 entry->opcode_nr = a2i (chp);
227 entry->parent = (*last)->path;
228 (*last)->path = entry;
229 chp = skip_digits (chp);
230 chp = skip_spaces (chp);
231 }
232 while (*chp == '.');
233 last = &(*last)->next;
234 }
235 while (*chp == ',');
236 if (*chp != '\0')
237 error (entry->line, "Invalid path field\n");
238 }
239
240 /* collect up the list of optional special conditions applicable
241 to the rule */
242 {
243 int field_nr = nr_decode_fields;
244 while (entry->nr_fields > field_nr)
245 {
246 decode_cond *cond = ZALLOC (decode_cond);
247 decode_cond **last;
248 if (entry->nr_fields > field_nr + decode_cond_mask_field)
249 set_bits (cond->mask,
250 a2i (entry->
251 field[field_nr + decode_cond_mask_field]));
252 if (entry->nr_fields > field_nr + decode_cond_value_field)
253 {
254 if (entry->field[field_nr + decode_cond_value_field][0] ==
255 '!')
256 {
257 cond->is_equal = 0;
258 set_bits (cond->value,
259 a2i (entry->
260 field[field_nr + decode_cond_value_field] +
261 1));
262 }
263 else
264 {
265 cond->is_equal = 1;
266 set_bits (cond->value,
267 a2i (entry->
268 field[field_nr +
269 decode_cond_value_field]));
270 }
271 }
272 if (entry->nr_fields > field_nr + decode_cond_word_nr_field)
273 cond->word_nr =
274 a2i (entry->field[field_nr + decode_cond_word_nr_field]);
275 field_nr += nr_decode_cond_fields;
276 /* insert it */
277 last = &new_rule->conditions;
278 while (*last != NULL)
279 last = &(*last)->next;
280 *last = cond;
281 }
282 }
283 *curr_rule = new_rule;
284 curr_rule = &new_rule->next;
285 }
286 return table;
287 }
288
289
290 int
decode_table_max_word_nr(decode_table * entry)291 decode_table_max_word_nr (decode_table *entry)
292 {
293 int max_word_nr = 0;
294 while (entry != NULL)
295 {
296 decode_cond *cond;
297 if (entry->word_nr > max_word_nr)
298 max_word_nr = entry->word_nr;
299 for (cond = entry->conditions; cond != NULL; cond = cond->next)
300 {
301 if (cond->word_nr > max_word_nr)
302 max_word_nr = cond->word_nr;
303 }
304 entry = entry->next;
305 }
306 return max_word_nr;
307 }
308
309
310
311 static void
dump_decode_cond(lf * file,char * prefix,decode_cond * cond,char * suffix)312 dump_decode_cond (lf *file, char *prefix, decode_cond *cond, char *suffix)
313 {
314 lf_printf (file, "%s(decode_cond *) 0x%lx", prefix, (long) cond);
315 if (cond != NULL)
316 {
317 lf_indent (file, +1);
318 lf_printf (file, "\n(word_nr %d)", cond->word_nr);
319 lf_printf (file, "\n(mask 0x%lx)", (long) cond->mask);
320 lf_printf (file, "\n(value 0x%lx)", (long) cond->value);
321 lf_printf (file, "\n(is_equal 0x%lx)", (long) cond->is_equal);
322 lf_printf (file, "\n(next (decode_cond *) 0%lx)", (long) cond->next);
323 lf_indent (file, -1);
324 }
325 lf_printf (file, "%s", suffix);
326 }
327
328
329 static void
dump_decode_conds(lf * file,char * prefix,decode_cond * cond,char * suffix)330 dump_decode_conds (lf *file, char *prefix, decode_cond *cond, char *suffix)
331 {
332 lf_printf (file, "%s(decode_cond *) 0x%lx", prefix, (long) cond);
333 while (cond != NULL)
334 {
335 dump_decode_cond (file, "\n(", cond, ")");
336 cond = cond->next;
337 }
338 lf_printf (file, "%s", suffix);
339 }
340
341
342 void
dump_decode_rule(lf * file,char * prefix,decode_table * rule,char * suffix)343 dump_decode_rule (lf *file, char *prefix, decode_table *rule, char *suffix)
344 {
345 lf_printf (file, "%s(decode_table *) 0x%lx", prefix, (long) rule);
346 if (rule != NULL)
347 {
348 lf_indent (file, +1);
349 dump_line_ref (file, "\n(line ", rule->line, ")");
350 lf_printf (file, "\n(type %s)", i2name (rule->type, decode_type_map));
351 lf_printf (file, "\n(gen %s)", i2name (rule->gen, decode_gen_map));
352 lf_printf (file, "\n(first %d)", rule->first);
353 lf_printf (file, "\n(last %d)", rule->last);
354 lf_printf (file, "\n(force_first %d)", rule->force_first);
355 lf_printf (file, "\n(force_last %d)", rule->force_last);
356 dump_filter (file, "\n(constant_field_names \"",
357 rule->constant_field_names, "\")");
358 lf_printf (file, "\n(constant 0x%x)", rule->constant);
359 lf_printf (file, "\n(word_nr %d)", rule->word_nr);
360 lf_printf (file, "\n(with_zero_reserved %d)", rule->with_zero_reserved);
361 lf_printf (file, "\n(with_duplicates %d)", rule->with_duplicates);
362 lf_printf (file, "\n(with_combine %d)", rule->with_combine);
363 dump_filter (file, "\n(format_names \"", rule->format_names, "\")");
364 dump_filter (file, "\n(model_names \"", rule->model_names, "\")");
365 dump_decode_conds (file, "\n(conditions ", rule->conditions, ")");
366 lf_printf (file, "\n(next 0x%lx)", (long) rule->next);
367 lf_indent (file, -1);
368 }
369 lf_printf (file, "%s", suffix);
370 }
371
372
373 #ifdef MAIN
374
375 static void
dump_decode_rules(lf * file,char * prefix,decode_table * rule,char * suffix)376 dump_decode_rules (lf *file, char *prefix, decode_table *rule, char *suffix)
377 {
378 lf_printf (file, "%s", prefix);
379 while (rule != NULL)
380 {
381 lf_indent (file, +1);
382 dump_decode_rule (file, "\n(", rule, ")");
383 lf_indent (file, -1);
384 rule = rule->next;
385 }
386 lf_printf (file, "%s", suffix);
387 }
388
389 igen_options options;
390
391 int
main(int argc,char ** argv)392 main (int argc, char **argv)
393 {
394 lf *l;
395 decode_table *rules;
396
397 INIT_OPTIONS (options);
398
399 if (argc != 3)
400 error (NULL, "Usage: decode <decode-file> <hi-bit-nr>\n");
401
402 options.hi_bit_nr = a2i (argv[2]);
403 rules = load_decode_table (argv[1]);
404 l = lf_open ("-", "stdout", lf_omit_references, lf_is_text, "tmp-ld-insn");
405 dump_decode_rules (l, "(rules ", rules, ")\n");
406
407 return 0;
408 }
409 #endif
410