1 |
330 |
jeremybenn |
/* This file is part of the program psim.
|
2 |
|
|
|
3 |
|
|
Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
|
4 |
|
|
|
5 |
|
|
This program is free software; you can redistribute it and/or modify
|
6 |
|
|
it under the terms of the GNU General Public License as published by
|
7 |
|
|
the Free Software Foundation; either version 2 of the License, or
|
8 |
|
|
(at your option) any later version.
|
9 |
|
|
|
10 |
|
|
This program is distributed in the hope that it will be useful,
|
11 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
12 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
13 |
|
|
GNU General Public License for more details.
|
14 |
|
|
|
15 |
|
|
You should have received a copy of the GNU General Public License
|
16 |
|
|
along with this program; if not, write to the Free Software
|
17 |
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
18 |
|
|
|
19 |
|
|
*/
|
20 |
|
|
|
21 |
|
|
|
22 |
|
|
#include "misc.h"
|
23 |
|
|
#include "lf.h"
|
24 |
|
|
#include "table.h"
|
25 |
|
|
|
26 |
|
|
#include "filter.h"
|
27 |
|
|
|
28 |
|
|
#include "ld-decode.h"
|
29 |
|
|
#include "ld-cache.h"
|
30 |
|
|
#include "ld-insn.h"
|
31 |
|
|
|
32 |
|
|
#include "igen.h"
|
33 |
|
|
|
34 |
|
|
#include "gen-semantics.h"
|
35 |
|
|
#include "gen-idecode.h"
|
36 |
|
|
#include "gen-icache.h"
|
37 |
|
|
|
38 |
|
|
|
39 |
|
|
|
40 |
|
|
static void
|
41 |
|
|
print_icache_function_header(lf *file,
|
42 |
|
|
const char *basename,
|
43 |
|
|
insn_bits *expanded_bits,
|
44 |
|
|
int is_function_definition)
|
45 |
|
|
{
|
46 |
|
|
lf_printf(file, "\n");
|
47 |
|
|
lf_print_function_type(file, ICACHE_FUNCTION_TYPE, "EXTERN_ICACHE", " ");
|
48 |
|
|
print_function_name(file,
|
49 |
|
|
basename,
|
50 |
|
|
expanded_bits,
|
51 |
|
|
function_name_prefix_icache);
|
52 |
|
|
lf_printf(file, "\n(%s)", ICACHE_FUNCTION_FORMAL);
|
53 |
|
|
if (!is_function_definition)
|
54 |
|
|
lf_printf(file, ";");
|
55 |
|
|
lf_printf(file, "\n");
|
56 |
|
|
}
|
57 |
|
|
|
58 |
|
|
|
59 |
|
|
void
|
60 |
|
|
print_icache_declaration(insn_table *entry,
|
61 |
|
|
lf *file,
|
62 |
|
|
void *data,
|
63 |
|
|
insn *instruction,
|
64 |
|
|
int depth)
|
65 |
|
|
{
|
66 |
|
|
if (generate_expanded_instructions) {
|
67 |
|
|
ASSERT(entry->nr_insn == 1);
|
68 |
|
|
print_icache_function_header(file,
|
69 |
|
|
entry->insns->file_entry->fields[insn_name],
|
70 |
|
|
entry->expanded_bits,
|
71 |
|
|
0/* is not function definition */);
|
72 |
|
|
}
|
73 |
|
|
else {
|
74 |
|
|
print_icache_function_header(file,
|
75 |
|
|
instruction->file_entry->fields[insn_name],
|
76 |
|
|
NULL,
|
77 |
|
|
0/* is not function definition */);
|
78 |
|
|
}
|
79 |
|
|
}
|
80 |
|
|
|
81 |
|
|
|
82 |
|
|
|
83 |
|
|
static void
|
84 |
|
|
print_icache_extraction(lf *file,
|
85 |
|
|
insn *instruction,
|
86 |
|
|
const char *entry_name,
|
87 |
|
|
const char *entry_type,
|
88 |
|
|
const char *entry_expression,
|
89 |
|
|
const char *original_name,
|
90 |
|
|
const char *file_name,
|
91 |
|
|
int line_nr,
|
92 |
|
|
insn_field *cur_field,
|
93 |
|
|
insn_bits *bits,
|
94 |
|
|
icache_decl_type what_to_declare,
|
95 |
|
|
icache_body_type what_to_do,
|
96 |
|
|
const char *reason)
|
97 |
|
|
{
|
98 |
|
|
const char *expression;
|
99 |
|
|
ASSERT(entry_name != NULL);
|
100 |
|
|
|
101 |
|
|
/* Define a storage area for the cache element */
|
102 |
|
|
if (what_to_declare == undef_variables) {
|
103 |
|
|
/* We've finished with the value - destory it */
|
104 |
|
|
lf_indent_suppress(file);
|
105 |
|
|
lf_printf(file, "#undef %s\n", entry_name);
|
106 |
|
|
return;
|
107 |
|
|
}
|
108 |
|
|
else if (what_to_declare == define_variables) {
|
109 |
|
|
lf_indent_suppress(file);
|
110 |
|
|
lf_printf(file, "#define %s ", entry_name);
|
111 |
|
|
}
|
112 |
|
|
else {
|
113 |
|
|
if (file_name != NULL)
|
114 |
|
|
lf_print__external_reference(file, line_nr, file_name);
|
115 |
|
|
lf_printf(file, "%s const %s UNUSED = ",
|
116 |
|
|
entry_type == NULL ? "unsigned" : entry_type,
|
117 |
|
|
entry_name);
|
118 |
|
|
}
|
119 |
|
|
|
120 |
|
|
/* define a value for that storage area as determined by what is in
|
121 |
|
|
the cache */
|
122 |
|
|
if (bits != NULL
|
123 |
|
|
&& strcmp(entry_name, cur_field->val_string) == 0
|
124 |
|
|
&& ((bits->opcode->is_boolean && bits->value == 0)
|
125 |
|
|
|| (!bits->opcode->is_boolean))) {
|
126 |
|
|
/* The simple field has been made constant (as a result of
|
127 |
|
|
expanding instructions or similar). Remember that for a
|
128 |
|
|
boolean field, value is either 0 (implying the required
|
129 |
|
|
boolean_constant) or nonzero (implying some other value and
|
130 |
|
|
handled later below) - Define the variable accordingly */
|
131 |
|
|
expression = "constant field";
|
132 |
|
|
ASSERT(bits->field == cur_field);
|
133 |
|
|
ASSERT(entry_type == NULL);
|
134 |
|
|
if (bits->opcode->is_boolean)
|
135 |
|
|
lf_printf(file, "%d", bits->opcode->boolean_constant);
|
136 |
|
|
else if (bits->opcode->last < bits->field->last)
|
137 |
|
|
lf_printf(file, "%d",
|
138 |
|
|
bits->value << (bits->field->last - bits->opcode->last));
|
139 |
|
|
else
|
140 |
|
|
lf_printf(file, "%d", bits->value);
|
141 |
|
|
}
|
142 |
|
|
else if (bits != NULL
|
143 |
|
|
&& original_name != NULL
|
144 |
|
|
&& strncmp(entry_name,
|
145 |
|
|
original_name, strlen(original_name)) == 0
|
146 |
|
|
&& strncmp(entry_name + strlen(original_name),
|
147 |
|
|
"_is_", strlen("_is_")) == 0
|
148 |
|
|
&& ((bits->opcode->is_boolean
|
149 |
|
|
&& (atol(entry_name + strlen(original_name) + strlen("_is_"))
|
150 |
|
|
== bits->opcode->boolean_constant))
|
151 |
|
|
|| (!bits->opcode->is_boolean))) {
|
152 |
|
|
expression = "constant compare";
|
153 |
|
|
/* An entry, derived from ORIGINAL_NAME, is testing to see of the
|
154 |
|
|
ORIGINAL_NAME has a specific constant value. That value
|
155 |
|
|
matching a boolean or constant field */
|
156 |
|
|
if (bits->opcode->is_boolean)
|
157 |
|
|
lf_printf(file, "%d /* %s == %d */",
|
158 |
|
|
bits->value == 0,
|
159 |
|
|
original_name,
|
160 |
|
|
bits->opcode->boolean_constant);
|
161 |
|
|
else if (bits->opcode->last < bits->field->last)
|
162 |
|
|
lf_printf(file, "%d /* %s == %d */",
|
163 |
|
|
(atol(entry_name + strlen(original_name) + strlen("_is_"))
|
164 |
|
|
== (bits->value << (bits->field->last - bits->opcode->last))),
|
165 |
|
|
original_name,
|
166 |
|
|
(bits->value << (bits->field->last - bits->opcode->last)));
|
167 |
|
|
else
|
168 |
|
|
lf_printf(file, "%d /* %s == %d */",
|
169 |
|
|
(atol(entry_name + strlen(original_name) + strlen("_is_"))
|
170 |
|
|
== bits->value),
|
171 |
|
|
original_name,
|
172 |
|
|
bits->value);
|
173 |
|
|
}
|
174 |
|
|
else {
|
175 |
|
|
/* put the field in the local variable, possibly also enter it
|
176 |
|
|
into the cache */
|
177 |
|
|
expression = "extraction";
|
178 |
|
|
/* handle the cache */
|
179 |
|
|
if ((what_to_do & get_values_from_icache)
|
180 |
|
|
|| (what_to_do & put_values_in_icache)) {
|
181 |
|
|
lf_printf(file, "cache_entry->crack.%s.%s",
|
182 |
|
|
instruction->file_entry->fields[insn_form],
|
183 |
|
|
entry_name);
|
184 |
|
|
if (what_to_do & put_values_in_icache) /* also put it in the cache? */
|
185 |
|
|
lf_printf(file, " = ");
|
186 |
|
|
}
|
187 |
|
|
if ((what_to_do & put_values_in_icache)
|
188 |
|
|
|| what_to_do == do_not_use_icache) {
|
189 |
|
|
if (cur_field != NULL && strcmp(entry_name, cur_field->val_string) == 0)
|
190 |
|
|
lf_printf(file, "EXTRACTED32(instruction, %d, %d)",
|
191 |
|
|
i2target(hi_bit_nr, cur_field->first),
|
192 |
|
|
i2target(hi_bit_nr, cur_field->last));
|
193 |
|
|
else if (entry_expression != NULL)
|
194 |
|
|
lf_printf(file, "%s", entry_expression);
|
195 |
|
|
else
|
196 |
|
|
lf_printf(file, "eval_%s", entry_name);
|
197 |
|
|
}
|
198 |
|
|
}
|
199 |
|
|
|
200 |
|
|
if (!((what_to_declare == define_variables)
|
201 |
|
|
|| (what_to_declare == undef_variables)))
|
202 |
|
|
lf_printf(file, ";");
|
203 |
|
|
if (reason != NULL)
|
204 |
|
|
lf_printf(file, " /* %s - %s */", reason, expression);
|
205 |
|
|
lf_printf(file, "\n");
|
206 |
|
|
}
|
207 |
|
|
|
208 |
|
|
|
209 |
|
|
void
|
210 |
|
|
print_icache_body(lf *file,
|
211 |
|
|
insn *instruction,
|
212 |
|
|
insn_bits *expanded_bits,
|
213 |
|
|
cache_table *cache_rules,
|
214 |
|
|
icache_decl_type what_to_declare,
|
215 |
|
|
icache_body_type what_to_do)
|
216 |
|
|
{
|
217 |
|
|
insn_field *cur_field;
|
218 |
|
|
|
219 |
|
|
/* extract instruction fields */
|
220 |
|
|
lf_printf(file, "/* extraction: %s ",
|
221 |
|
|
instruction->file_entry->fields[insn_format]);
|
222 |
|
|
switch (what_to_declare) {
|
223 |
|
|
case define_variables:
|
224 |
|
|
lf_printf(file, "#define");
|
225 |
|
|
break;
|
226 |
|
|
case declare_variables:
|
227 |
|
|
lf_printf(file, "declare");
|
228 |
|
|
break;
|
229 |
|
|
case undef_variables:
|
230 |
|
|
lf_printf(file, "#undef");
|
231 |
|
|
break;
|
232 |
|
|
}
|
233 |
|
|
lf_printf(file, " ");
|
234 |
|
|
switch (what_to_do) {
|
235 |
|
|
case get_values_from_icache:
|
236 |
|
|
lf_printf(file, "get-values-from-icache");
|
237 |
|
|
break;
|
238 |
|
|
case put_values_in_icache:
|
239 |
|
|
lf_printf(file, "put-values-in-icache");
|
240 |
|
|
break;
|
241 |
|
|
case both_values_and_icache:
|
242 |
|
|
lf_printf(file, "get-values-from-icache|put-values-in-icache");
|
243 |
|
|
break;
|
244 |
|
|
case do_not_use_icache:
|
245 |
|
|
lf_printf(file, "do-not-use-icache");
|
246 |
|
|
break;
|
247 |
|
|
}
|
248 |
|
|
lf_printf(file, " */\n");
|
249 |
|
|
|
250 |
|
|
for (cur_field = instruction->fields->first;
|
251 |
|
|
cur_field->first < insn_bit_size;
|
252 |
|
|
cur_field = cur_field->next) {
|
253 |
|
|
if (cur_field->is_string) {
|
254 |
|
|
insn_bits *bits;
|
255 |
|
|
int found_rule = 0;
|
256 |
|
|
/* find any corresponding value */
|
257 |
|
|
for (bits = expanded_bits;
|
258 |
|
|
bits != NULL;
|
259 |
|
|
bits = bits->last) {
|
260 |
|
|
if (bits->field == cur_field)
|
261 |
|
|
break;
|
262 |
|
|
}
|
263 |
|
|
/* try the cache rule table for what to do */
|
264 |
|
|
{
|
265 |
|
|
cache_table *cache_rule;
|
266 |
|
|
for (cache_rule = cache_rules;
|
267 |
|
|
cache_rule != NULL;
|
268 |
|
|
cache_rule = cache_rule->next) {
|
269 |
|
|
if (strcmp(cur_field->val_string, cache_rule->field_name) == 0) {
|
270 |
|
|
found_rule = 1;
|
271 |
|
|
if (cache_rule->type == scratch_value
|
272 |
|
|
&& ((what_to_do & put_values_in_icache)
|
273 |
|
|
|| what_to_do == do_not_use_icache))
|
274 |
|
|
print_icache_extraction(file,
|
275 |
|
|
instruction,
|
276 |
|
|
cache_rule->derived_name,
|
277 |
|
|
cache_rule->type_def,
|
278 |
|
|
cache_rule->expression,
|
279 |
|
|
cache_rule->field_name,
|
280 |
|
|
cache_rule->file_entry->file_name,
|
281 |
|
|
cache_rule->file_entry->line_nr,
|
282 |
|
|
cur_field,
|
283 |
|
|
bits,
|
284 |
|
|
what_to_declare,
|
285 |
|
|
do_not_use_icache,
|
286 |
|
|
"icache scratch");
|
287 |
|
|
else if (cache_rule->type == compute_value
|
288 |
|
|
&& ((what_to_do & get_values_from_icache)
|
289 |
|
|
|| what_to_do == do_not_use_icache))
|
290 |
|
|
print_icache_extraction(file,
|
291 |
|
|
instruction,
|
292 |
|
|
cache_rule->derived_name,
|
293 |
|
|
cache_rule->type_def,
|
294 |
|
|
cache_rule->expression,
|
295 |
|
|
cache_rule->field_name,
|
296 |
|
|
cache_rule->file_entry->file_name,
|
297 |
|
|
cache_rule->file_entry->line_nr,
|
298 |
|
|
cur_field,
|
299 |
|
|
bits,
|
300 |
|
|
what_to_declare,
|
301 |
|
|
do_not_use_icache,
|
302 |
|
|
"semantic compute");
|
303 |
|
|
else if (cache_rule->type == cache_value
|
304 |
|
|
&& ((what_to_declare != undef_variables)
|
305 |
|
|
|| !(what_to_do & put_values_in_icache)))
|
306 |
|
|
print_icache_extraction(file,
|
307 |
|
|
instruction,
|
308 |
|
|
cache_rule->derived_name,
|
309 |
|
|
cache_rule->type_def,
|
310 |
|
|
cache_rule->expression,
|
311 |
|
|
cache_rule->field_name,
|
312 |
|
|
cache_rule->file_entry->file_name,
|
313 |
|
|
cache_rule->file_entry->line_nr,
|
314 |
|
|
cur_field,
|
315 |
|
|
bits,
|
316 |
|
|
((what_to_do & put_values_in_icache)
|
317 |
|
|
? declare_variables
|
318 |
|
|
: what_to_declare),
|
319 |
|
|
what_to_do,
|
320 |
|
|
"in icache");
|
321 |
|
|
}
|
322 |
|
|
}
|
323 |
|
|
}
|
324 |
|
|
/* No rule at all, assume that this is needed in the semantic
|
325 |
|
|
function (when values are extracted from the icache) and
|
326 |
|
|
hence must be put into the cache */
|
327 |
|
|
if (found_rule == 0
|
328 |
|
|
&& ((what_to_declare != undef_variables)
|
329 |
|
|
|| !(what_to_do & put_values_in_icache)))
|
330 |
|
|
print_icache_extraction(file,
|
331 |
|
|
instruction,
|
332 |
|
|
cur_field->val_string,
|
333 |
|
|
NULL, NULL, NULL, /* type, exp, orig */
|
334 |
|
|
instruction->file_entry->file_name,
|
335 |
|
|
instruction->file_entry->line_nr,
|
336 |
|
|
cur_field,
|
337 |
|
|
bits,
|
338 |
|
|
((what_to_do & put_values_in_icache)
|
339 |
|
|
? declare_variables
|
340 |
|
|
: what_to_declare),
|
341 |
|
|
what_to_do,
|
342 |
|
|
"default in icache");
|
343 |
|
|
/* any thing else ... */
|
344 |
|
|
}
|
345 |
|
|
}
|
346 |
|
|
|
347 |
|
|
lf_print__internal_reference(file);
|
348 |
|
|
|
349 |
|
|
if ((code & generate_with_insn_in_icache)) {
|
350 |
|
|
lf_printf(file, "\n");
|
351 |
|
|
print_icache_extraction(file,
|
352 |
|
|
instruction,
|
353 |
|
|
"insn",
|
354 |
|
|
"instruction_word",
|
355 |
|
|
"instruction",
|
356 |
|
|
NULL, /* origin */
|
357 |
|
|
NULL, 0, /* file_name & line_nr */
|
358 |
|
|
NULL, NULL,
|
359 |
|
|
what_to_declare,
|
360 |
|
|
what_to_do,
|
361 |
|
|
NULL);
|
362 |
|
|
}
|
363 |
|
|
}
|
364 |
|
|
|
365 |
|
|
|
366 |
|
|
|
367 |
|
|
typedef struct _icache_tree icache_tree;
|
368 |
|
|
struct _icache_tree {
|
369 |
|
|
char *name;
|
370 |
|
|
icache_tree *next;
|
371 |
|
|
icache_tree *children;
|
372 |
|
|
};
|
373 |
|
|
|
374 |
|
|
static icache_tree *
|
375 |
|
|
icache_tree_insert(icache_tree *tree,
|
376 |
|
|
char *name)
|
377 |
|
|
{
|
378 |
|
|
icache_tree *new_tree;
|
379 |
|
|
/* find it */
|
380 |
|
|
icache_tree **ptr_to_cur_tree = &tree->children;
|
381 |
|
|
icache_tree *cur_tree = *ptr_to_cur_tree;
|
382 |
|
|
while (cur_tree != NULL
|
383 |
|
|
&& strcmp(cur_tree->name, name) < 0) {
|
384 |
|
|
ptr_to_cur_tree = &cur_tree->next;
|
385 |
|
|
cur_tree = *ptr_to_cur_tree;
|
386 |
|
|
}
|
387 |
|
|
ASSERT(cur_tree == NULL
|
388 |
|
|
|| strcmp(cur_tree->name, name) >= 0);
|
389 |
|
|
/* already in the tree */
|
390 |
|
|
if (cur_tree != NULL
|
391 |
|
|
&& strcmp(cur_tree->name, name) == 0)
|
392 |
|
|
return cur_tree;
|
393 |
|
|
/* missing, insert it */
|
394 |
|
|
ASSERT(cur_tree == NULL
|
395 |
|
|
|| strcmp(cur_tree->name, name) > 0);
|
396 |
|
|
new_tree = ZALLOC(icache_tree);
|
397 |
|
|
new_tree->name = name;
|
398 |
|
|
new_tree->next = cur_tree;
|
399 |
|
|
*ptr_to_cur_tree = new_tree;
|
400 |
|
|
return new_tree;
|
401 |
|
|
}
|
402 |
|
|
|
403 |
|
|
|
404 |
|
|
static icache_tree *
|
405 |
|
|
insn_table_cache_fields(insn_table *table)
|
406 |
|
|
{
|
407 |
|
|
icache_tree *tree = ZALLOC(icache_tree);
|
408 |
|
|
insn *instruction;
|
409 |
|
|
for (instruction = table->insns;
|
410 |
|
|
instruction != NULL;
|
411 |
|
|
instruction = instruction->next) {
|
412 |
|
|
insn_field *field;
|
413 |
|
|
icache_tree *form =
|
414 |
|
|
icache_tree_insert(tree,
|
415 |
|
|
instruction->file_entry->fields[insn_form]);
|
416 |
|
|
for (field = instruction->fields->first;
|
417 |
|
|
field != NULL;
|
418 |
|
|
field = field->next) {
|
419 |
|
|
if (field->is_string)
|
420 |
|
|
icache_tree_insert(form, field->val_string);
|
421 |
|
|
}
|
422 |
|
|
}
|
423 |
|
|
return tree;
|
424 |
|
|
}
|
425 |
|
|
|
426 |
|
|
|
427 |
|
|
|
428 |
|
|
extern void
|
429 |
|
|
print_icache_struct(insn_table *instructions,
|
430 |
|
|
cache_table *cache_rules,
|
431 |
|
|
lf *file)
|
432 |
|
|
{
|
433 |
|
|
icache_tree *tree = insn_table_cache_fields(instructions);
|
434 |
|
|
|
435 |
|
|
lf_printf(file, "\n");
|
436 |
|
|
lf_printf(file, "#define WITH_IDECODE_CACHE_SIZE %d\n",
|
437 |
|
|
(code & generate_with_icache) ? icache_size : 0);
|
438 |
|
|
lf_printf(file, "\n");
|
439 |
|
|
|
440 |
|
|
/* create an instruction cache if being used */
|
441 |
|
|
if ((code & generate_with_icache)) {
|
442 |
|
|
icache_tree *form;
|
443 |
|
|
lf_printf(file, "typedef struct _idecode_cache {\n");
|
444 |
|
|
lf_printf(file, " unsigned_word address;\n");
|
445 |
|
|
lf_printf(file, " void *semantic;\n");
|
446 |
|
|
lf_printf(file, " union {\n");
|
447 |
|
|
for (form = tree->children;
|
448 |
|
|
form != NULL;
|
449 |
|
|
form = form->next) {
|
450 |
|
|
icache_tree *field;
|
451 |
|
|
lf_printf(file, " struct {\n");
|
452 |
|
|
if (code & generate_with_insn_in_icache)
|
453 |
|
|
lf_printf(file, " instruction_word insn;\n");
|
454 |
|
|
for (field = form->children;
|
455 |
|
|
field != NULL;
|
456 |
|
|
field = field->next) {
|
457 |
|
|
cache_table *cache_rule;
|
458 |
|
|
int found_rule = 0;
|
459 |
|
|
for (cache_rule = cache_rules;
|
460 |
|
|
cache_rule != NULL;
|
461 |
|
|
cache_rule = cache_rule->next) {
|
462 |
|
|
if (strcmp(field->name, cache_rule->field_name) == 0) {
|
463 |
|
|
found_rule = 1;
|
464 |
|
|
if (cache_rule->derived_name != NULL)
|
465 |
|
|
lf_printf(file, " %s %s; /* %s */\n",
|
466 |
|
|
(cache_rule->type_def == NULL
|
467 |
|
|
? "unsigned"
|
468 |
|
|
: cache_rule->type_def),
|
469 |
|
|
cache_rule->derived_name,
|
470 |
|
|
cache_rule->field_name);
|
471 |
|
|
}
|
472 |
|
|
}
|
473 |
|
|
if (!found_rule)
|
474 |
|
|
lf_printf(file, " unsigned %s;\n", field->name);
|
475 |
|
|
}
|
476 |
|
|
lf_printf(file, " } %s;\n", form->name);
|
477 |
|
|
}
|
478 |
|
|
lf_printf(file, " } crack;\n");
|
479 |
|
|
lf_printf(file, "} idecode_cache;\n");
|
480 |
|
|
}
|
481 |
|
|
else {
|
482 |
|
|
/* alernativly, since no cache, emit a dummy definition for
|
483 |
|
|
idecode_cache so that code refering to the type can still compile */
|
484 |
|
|
lf_printf(file, "typedef void idecode_cache;\n");
|
485 |
|
|
}
|
486 |
|
|
lf_printf(file, "\n");
|
487 |
|
|
}
|
488 |
|
|
|
489 |
|
|
|
490 |
|
|
|
491 |
|
|
static void
|
492 |
|
|
print_icache_function(lf *file,
|
493 |
|
|
insn *instruction,
|
494 |
|
|
insn_bits *expanded_bits,
|
495 |
|
|
opcode_field *opcodes,
|
496 |
|
|
cache_table *cache_rules)
|
497 |
|
|
{
|
498 |
|
|
int indent;
|
499 |
|
|
|
500 |
|
|
/* generate code to enter decoded instruction into the icache */
|
501 |
|
|
lf_printf(file, "\n");
|
502 |
|
|
lf_print_function_type(file, ICACHE_FUNCTION_TYPE, "EXTERN_ICACHE", "\n");
|
503 |
|
|
indent = print_function_name(file,
|
504 |
|
|
instruction->file_entry->fields[insn_name],
|
505 |
|
|
expanded_bits,
|
506 |
|
|
function_name_prefix_icache);
|
507 |
|
|
lf_indent(file, +indent);
|
508 |
|
|
lf_printf(file, "(%s)\n", ICACHE_FUNCTION_FORMAL);
|
509 |
|
|
lf_indent(file, -indent);
|
510 |
|
|
|
511 |
|
|
/* function header */
|
512 |
|
|
lf_printf(file, "{\n");
|
513 |
|
|
lf_indent(file, +2);
|
514 |
|
|
|
515 |
|
|
print_my_defines(file, expanded_bits, instruction->file_entry);
|
516 |
|
|
print_itrace(file, instruction->file_entry, 1/*putting-value-in-cache*/);
|
517 |
|
|
|
518 |
|
|
print_idecode_validate(file, instruction, opcodes);
|
519 |
|
|
|
520 |
|
|
lf_printf(file, "\n");
|
521 |
|
|
lf_printf(file, "{\n");
|
522 |
|
|
lf_indent(file, +2);
|
523 |
|
|
if ((code & generate_with_semantic_icache))
|
524 |
|
|
lf_printf(file, "unsigned_word nia;\n");
|
525 |
|
|
print_icache_body(file,
|
526 |
|
|
instruction,
|
527 |
|
|
expanded_bits,
|
528 |
|
|
cache_rules,
|
529 |
|
|
((code & generate_with_direct_access)
|
530 |
|
|
? define_variables
|
531 |
|
|
: declare_variables),
|
532 |
|
|
((code & generate_with_semantic_icache)
|
533 |
|
|
? both_values_and_icache
|
534 |
|
|
: put_values_in_icache));
|
535 |
|
|
|
536 |
|
|
lf_printf(file, "\n");
|
537 |
|
|
lf_printf(file, "cache_entry->address = cia;\n");
|
538 |
|
|
lf_printf(file, "cache_entry->semantic = ");
|
539 |
|
|
print_function_name(file,
|
540 |
|
|
instruction->file_entry->fields[insn_name],
|
541 |
|
|
expanded_bits,
|
542 |
|
|
function_name_prefix_semantics);
|
543 |
|
|
lf_printf(file, ";\n");
|
544 |
|
|
lf_printf(file, "\n");
|
545 |
|
|
|
546 |
|
|
if ((code & generate_with_semantic_icache)) {
|
547 |
|
|
lf_printf(file, "/* semantic routine */\n");
|
548 |
|
|
print_semantic_body(file,
|
549 |
|
|
instruction,
|
550 |
|
|
expanded_bits,
|
551 |
|
|
opcodes);
|
552 |
|
|
lf_printf(file, "return nia;\n");
|
553 |
|
|
}
|
554 |
|
|
|
555 |
|
|
if (!(code & generate_with_semantic_icache)) {
|
556 |
|
|
lf_printf(file, "/* return the function proper */\n");
|
557 |
|
|
lf_printf(file, "return ");
|
558 |
|
|
print_function_name(file,
|
559 |
|
|
instruction->file_entry->fields[insn_name],
|
560 |
|
|
expanded_bits,
|
561 |
|
|
function_name_prefix_semantics);
|
562 |
|
|
lf_printf(file, ";\n");
|
563 |
|
|
}
|
564 |
|
|
|
565 |
|
|
if ((code & generate_with_direct_access))
|
566 |
|
|
print_icache_body(file,
|
567 |
|
|
instruction,
|
568 |
|
|
expanded_bits,
|
569 |
|
|
cache_rules,
|
570 |
|
|
undef_variables,
|
571 |
|
|
((code & generate_with_semantic_icache)
|
572 |
|
|
? both_values_and_icache
|
573 |
|
|
: put_values_in_icache));
|
574 |
|
|
|
575 |
|
|
lf_indent(file, -2);
|
576 |
|
|
lf_printf(file, "}\n");
|
577 |
|
|
lf_indent(file, -2);
|
578 |
|
|
lf_printf(file, "}\n");
|
579 |
|
|
}
|
580 |
|
|
|
581 |
|
|
|
582 |
|
|
void
|
583 |
|
|
print_icache_definition(insn_table *entry,
|
584 |
|
|
lf *file,
|
585 |
|
|
void *data,
|
586 |
|
|
insn *instruction,
|
587 |
|
|
int depth)
|
588 |
|
|
{
|
589 |
|
|
cache_table *cache_rules = (cache_table*)data;
|
590 |
|
|
if (generate_expanded_instructions) {
|
591 |
|
|
ASSERT(entry->nr_insn == 1
|
592 |
|
|
&& entry->opcode == NULL
|
593 |
|
|
&& entry->parent != NULL
|
594 |
|
|
&& entry->parent->opcode != NULL);
|
595 |
|
|
ASSERT(entry->nr_insn == 1
|
596 |
|
|
&& entry->opcode == NULL
|
597 |
|
|
&& entry->parent != NULL
|
598 |
|
|
&& entry->parent->opcode != NULL
|
599 |
|
|
&& entry->parent->opcode_rule != NULL);
|
600 |
|
|
print_icache_function(file,
|
601 |
|
|
entry->insns,
|
602 |
|
|
entry->expanded_bits,
|
603 |
|
|
entry->opcode,
|
604 |
|
|
cache_rules);
|
605 |
|
|
}
|
606 |
|
|
else {
|
607 |
|
|
print_icache_function(file,
|
608 |
|
|
instruction,
|
609 |
|
|
NULL,
|
610 |
|
|
NULL,
|
611 |
|
|
cache_rules);
|
612 |
|
|
}
|
613 |
|
|
}
|
614 |
|
|
|
615 |
|
|
|
616 |
|
|
|
617 |
|
|
void
|
618 |
|
|
print_icache_internal_function_declaration(insn_table *table,
|
619 |
|
|
lf *file,
|
620 |
|
|
void *data,
|
621 |
|
|
table_entry *function)
|
622 |
|
|
{
|
623 |
|
|
ASSERT((code & generate_with_icache) != 0);
|
624 |
|
|
if (it_is("internal", function->fields[insn_flags])) {
|
625 |
|
|
lf_printf(file, "\n");
|
626 |
|
|
lf_print_function_type(file, ICACHE_FUNCTION_TYPE, "PSIM_INLINE_ICACHE",
|
627 |
|
|
"\n");
|
628 |
|
|
print_function_name(file,
|
629 |
|
|
function->fields[insn_name],
|
630 |
|
|
NULL,
|
631 |
|
|
function_name_prefix_icache);
|
632 |
|
|
lf_printf(file, "\n(%s);\n", ICACHE_FUNCTION_FORMAL);
|
633 |
|
|
}
|
634 |
|
|
}
|
635 |
|
|
|
636 |
|
|
|
637 |
|
|
void
|
638 |
|
|
print_icache_internal_function_definition(insn_table *table,
|
639 |
|
|
lf *file,
|
640 |
|
|
void *data,
|
641 |
|
|
table_entry *function)
|
642 |
|
|
{
|
643 |
|
|
ASSERT((code & generate_with_icache) != 0);
|
644 |
|
|
if (it_is("internal", function->fields[insn_flags])) {
|
645 |
|
|
lf_printf(file, "\n");
|
646 |
|
|
lf_print_function_type(file, ICACHE_FUNCTION_TYPE, "PSIM_INLINE_ICACHE",
|
647 |
|
|
"\n");
|
648 |
|
|
print_function_name(file,
|
649 |
|
|
function->fields[insn_name],
|
650 |
|
|
NULL,
|
651 |
|
|
function_name_prefix_icache);
|
652 |
|
|
lf_printf(file, "\n(%s)\n", ICACHE_FUNCTION_FORMAL);
|
653 |
|
|
lf_printf(file, "{\n");
|
654 |
|
|
lf_indent(file, +2);
|
655 |
|
|
lf_printf(file, "/* semantic routine */\n");
|
656 |
|
|
table_entry_print_cpp_line_nr(file, function);
|
657 |
|
|
if ((code & generate_with_semantic_icache)) {
|
658 |
|
|
lf_print__c_code(file, function->annex);
|
659 |
|
|
lf_printf(file, "error(\"Internal function must longjump\\n\");\n");
|
660 |
|
|
lf_printf(file, "return 0;\n");
|
661 |
|
|
}
|
662 |
|
|
else {
|
663 |
|
|
lf_printf(file, "return ");
|
664 |
|
|
print_function_name(file,
|
665 |
|
|
function->fields[insn_name],
|
666 |
|
|
NULL,
|
667 |
|
|
function_name_prefix_semantics);
|
668 |
|
|
lf_printf(file, ";\n");
|
669 |
|
|
}
|
670 |
|
|
|
671 |
|
|
lf_print__internal_reference(file);
|
672 |
|
|
lf_indent(file, -2);
|
673 |
|
|
lf_printf(file, "}\n");
|
674 |
|
|
}
|
675 |
|
|
}
|