* gen-icache.c (print_icache_extraction): When generating #define
force the expression to the correct type.
This commit is contained in:
Andrew Cagney
parent
970a8fd6c3
commit
98f5dae13b
@ -1,3 +1,19 @@
|
||||
Tue Apr 21 01:37:54 1998 Andrew Cagney <cagney@b1.cygnus.com>
|
||||
|
||||
* gen-icache.c (print_icache_extraction): When generating #define
|
||||
force the expression to the correct type.
|
||||
|
||||
Thu Apr 16 08:50:29 1998 Andrew Cagney <cagney@b1.cygnus.com>
|
||||
|
||||
* misc.c (name2i): strlen returns an unsigned.
|
||||
|
||||
Tue Apr 14 19:04:28 1998 Andrew Cagney <cagney@b1.cygnus.com>
|
||||
|
||||
* igen.h (struct igen_warn_options): Add unimplemented option.
|
||||
* igen.c (main): Update
|
||||
|
||||
* ld-insn.c (load_insn_table): Report unimplemented functions.
|
||||
|
||||
Tue Apr 14 10:57:26 1998 Andrew Cagney <cagney@b1.cygnus.com>
|
||||
|
||||
* ld-insn.c (parse_insn_word): Treat `!' and `=' as valid
|
||||
|
||||
852
sim/igen/gen-icache.c
Normal file
852
sim/igen/gen-icache.c
Normal file
@ -0,0 +1,852 @@
|
||||
/* This file is part of the program psim.
|
||||
|
||||
Copyright (C) 1994-1998, Andrew Cagney <cagney@highland.com.au>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
*/
|
||||
|
||||
|
||||
#include "misc.h"
|
||||
#include "lf.h"
|
||||
#include "table.h"
|
||||
#include "filter.h"
|
||||
#include "igen.h"
|
||||
|
||||
#include "ld-insn.h"
|
||||
#include "ld-decode.h"
|
||||
|
||||
#include "gen.h"
|
||||
|
||||
#include "gen-semantics.h"
|
||||
#include "gen-idecode.h"
|
||||
#include "gen-icache.h"
|
||||
|
||||
|
||||
|
||||
static void
|
||||
print_icache_function_header (lf *file,
|
||||
const char *basename,
|
||||
const char *format_name,
|
||||
opcode_bits *expanded_bits,
|
||||
int is_function_definition,
|
||||
int nr_prefetched_words)
|
||||
{
|
||||
lf_printf(file, "\n");
|
||||
lf_print__function_type_function (file, print_icache_function_type,
|
||||
"EXTERN_ICACHE", " ");
|
||||
print_function_name (file,
|
||||
basename, format_name, NULL,
|
||||
expanded_bits,
|
||||
function_name_prefix_icache);
|
||||
lf_printf (file, "\n(");
|
||||
print_icache_function_formal (file, nr_prefetched_words);
|
||||
lf_printf (file, ")");
|
||||
if (!is_function_definition)
|
||||
lf_printf (file, ";");
|
||||
lf_printf (file, "\n");
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
print_icache_declaration (lf *file,
|
||||
insn_entry *insn,
|
||||
opcode_bits *expanded_bits,
|
||||
insn_opcodes *opcodes,
|
||||
int nr_prefetched_words)
|
||||
{
|
||||
print_icache_function_header (file,
|
||||
insn->name,
|
||||
insn->format_name,
|
||||
expanded_bits,
|
||||
0/* is not function definition */,
|
||||
nr_prefetched_words);
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void
|
||||
print_icache_extraction (lf *file,
|
||||
const char *format_name,
|
||||
cache_entry_type cache_type,
|
||||
const char *entry_name,
|
||||
const char *entry_type,
|
||||
const char *entry_expression,
|
||||
char *single_insn_field,
|
||||
line_ref *line,
|
||||
insn_field_entry *cur_field,
|
||||
opcode_bits *expanded_bits,
|
||||
icache_decl_type what_to_declare,
|
||||
icache_body_type what_to_do)
|
||||
{
|
||||
const char *expression;
|
||||
opcode_bits *bits;
|
||||
char *reason;
|
||||
ASSERT (format_name != NULL);
|
||||
ASSERT (entry_name != NULL);
|
||||
|
||||
/* figure out exactly what should be going on here */
|
||||
switch (cache_type)
|
||||
{
|
||||
case scratch_value:
|
||||
if ((what_to_do & put_values_in_icache)
|
||||
|| what_to_do == do_not_use_icache)
|
||||
{
|
||||
reason = "scratch";
|
||||
what_to_do = do_not_use_icache;
|
||||
}
|
||||
else
|
||||
return;
|
||||
break;
|
||||
case compute_value:
|
||||
if ((what_to_do & get_values_from_icache)
|
||||
|| what_to_do == do_not_use_icache)
|
||||
{
|
||||
reason = "compute";
|
||||
what_to_do = do_not_use_icache;
|
||||
}
|
||||
else
|
||||
return;
|
||||
break;
|
||||
case cache_value:
|
||||
if ((what_to_declare != undef_variables)
|
||||
|| !(what_to_do & put_values_in_icache))
|
||||
{
|
||||
reason = "cache";
|
||||
what_to_declare = ((what_to_do & put_values_in_icache)
|
||||
? declare_variables
|
||||
: what_to_declare);
|
||||
}
|
||||
else
|
||||
return;
|
||||
break;
|
||||
}
|
||||
|
||||
/* For the type, default to a simple unsigned */
|
||||
if (entry_type == NULL || strlen (entry_type) == 0)
|
||||
entry_type = "unsigned";
|
||||
|
||||
/* look through the set of expanded sub fields to see if this field
|
||||
has been given a constant value */
|
||||
for (bits = expanded_bits;
|
||||
bits != NULL;
|
||||
bits = bits->next)
|
||||
{
|
||||
if (bits->field == cur_field)
|
||||
break;
|
||||
}
|
||||
|
||||
/* Define a storage area for the cache element */
|
||||
switch (what_to_declare)
|
||||
{
|
||||
case undef_variables:
|
||||
/* We've finished with the #define value - destory it */
|
||||
lf_indent_suppress (file);
|
||||
lf_printf (file, "#undef %s\n", entry_name);
|
||||
return;
|
||||
case define_variables:
|
||||
/* Using direct access for this entry, define it */
|
||||
lf_indent_suppress (file);
|
||||
lf_printf (file, "#define %s ((%s) ", entry_name, entry_type);
|
||||
break;
|
||||
case declare_variables:
|
||||
/* using variables to define the value */
|
||||
if (line != NULL)
|
||||
lf_print__line_ref (file, line);
|
||||
lf_printf (file, "%s const %s UNUSED = ", entry_type, entry_name);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/* define a value for that storage area as determined by what is in
|
||||
the cache */
|
||||
if (bits != NULL
|
||||
&& single_insn_field != NULL
|
||||
&& strcmp (entry_name, single_insn_field) == 0
|
||||
&& strcmp (entry_name, cur_field->val_string) == 0
|
||||
&& ((bits->opcode->is_boolean && bits->value == 0)
|
||||
|| (!bits->opcode->is_boolean)))
|
||||
{
|
||||
/* The cache rule is specifying what to do with a simple
|
||||
instruction field.
|
||||
|
||||
Because of instruction expansion, the field is either a
|
||||
constant value or equal to the specified constant (boolean
|
||||
comparison). (The latter indicated by bits->value == 0).
|
||||
|
||||
The case of a field not being equal to the specified boolean
|
||||
value is handled later. */
|
||||
expression = "constant field";
|
||||
ASSERT (bits->field == cur_field);
|
||||
if (bits->opcode->is_boolean)
|
||||
{
|
||||
ASSERT (bits->value == 0);
|
||||
lf_printf (file, "%d", bits->opcode->boolean_constant);
|
||||
}
|
||||
else if (bits->opcode->last < bits->field->last)
|
||||
{
|
||||
lf_printf (file, "%d",
|
||||
bits->value << (bits->field->last - bits->opcode->last));
|
||||
}
|
||||
else
|
||||
{
|
||||
lf_printf (file, "%d", bits->value);
|
||||
}
|
||||
}
|
||||
else if (bits != NULL
|
||||
&& single_insn_field != NULL
|
||||
&& strncmp (entry_name,
|
||||
single_insn_field,
|
||||
strlen (single_insn_field)) == 0
|
||||
&& strncmp (entry_name + strlen (single_insn_field),
|
||||
"_is_",
|
||||
strlen ("_is_")) == 0
|
||||
&& ((bits->opcode->is_boolean
|
||||
&& ((unsigned) atol (entry_name + strlen (single_insn_field) + strlen ("_is_"))
|
||||
== bits->opcode->boolean_constant))
|
||||
|| (!bits->opcode->is_boolean)))
|
||||
{
|
||||
/* The cache rule defines an entry for the comparison between a
|
||||
single instruction field and a constant. The value of the
|
||||
comparison in someway matches that of the opcode field that
|
||||
was made constant through expansion. */
|
||||
expression = "constant compare";
|
||||
if (bits->opcode->is_boolean)
|
||||
{
|
||||
lf_printf (file, "%d /* %s == %d */",
|
||||
bits->value == 0,
|
||||
single_insn_field,
|
||||
bits->opcode->boolean_constant);
|
||||
}
|
||||
else if (bits->opcode->last < bits->field->last)
|
||||
{
|
||||
lf_printf (file, "%d /* %s == %d */",
|
||||
(atol (entry_name + strlen (single_insn_field) + strlen ("_is_"))
|
||||
== (bits->value << (bits->field->last - bits->opcode->last))),
|
||||
single_insn_field,
|
||||
(bits->value << (bits->field->last - bits->opcode->last)));
|
||||
}
|
||||
else
|
||||
{
|
||||
lf_printf (file, "%d /* %s == %d */",
|
||||
(atol (entry_name + strlen (single_insn_field) + strlen ("_is_"))
|
||||
== bits->value),
|
||||
single_insn_field,
|
||||
bits->value);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* put the field in the local variable, possibly also enter it
|
||||
into the cache */
|
||||
expression = "extraction";
|
||||
/* handle the cache */
|
||||
if ((what_to_do & get_values_from_icache)
|
||||
|| (what_to_do & put_values_in_icache))
|
||||
{
|
||||
lf_printf (file, "cache_entry->crack.%s.%s",
|
||||
format_name,
|
||||
entry_name);
|
||||
if (what_to_do & put_values_in_icache) /* also put it in the cache? */
|
||||
{
|
||||
lf_printf (file, " = ");
|
||||
}
|
||||
}
|
||||
if ((what_to_do & put_values_in_icache)
|
||||
|| what_to_do == do_not_use_icache)
|
||||
{
|
||||
if (cur_field != NULL)
|
||||
{
|
||||
if (entry_expression != NULL && strlen (entry_expression) > 0)
|
||||
error (line, "Instruction field entry with nonempty expression\n");
|
||||
if (cur_field->first == 0 && cur_field->last == options.insn_bit_size - 1)
|
||||
lf_printf (file, "(instruction_%d)",
|
||||
cur_field->word_nr);
|
||||
else if (cur_field->last == options.insn_bit_size - 1)
|
||||
lf_printf (file, "MASKED%d (instruction_%d, %d, %d)",
|
||||
options.insn_bit_size,
|
||||
cur_field->word_nr,
|
||||
i2target (options.hi_bit_nr, cur_field->first),
|
||||
i2target (options.hi_bit_nr, cur_field->last));
|
||||
else
|
||||
lf_printf (file, "EXTRACTED%d (instruction_%d, %d, %d)",
|
||||
options.insn_bit_size,
|
||||
cur_field->word_nr,
|
||||
i2target (options.hi_bit_nr, cur_field->first),
|
||||
i2target (options.hi_bit_nr, cur_field->last));
|
||||
}
|
||||
else
|
||||
{
|
||||
lf_printf (file, "%s", entry_expression);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
switch (what_to_declare)
|
||||
{
|
||||
case define_variables:
|
||||
lf_printf (file, ")");
|
||||
break;
|
||||
case undef_variables:
|
||||
break;
|
||||
case declare_variables:
|
||||
lf_printf (file, ";");
|
||||
break;
|
||||
}
|
||||
|
||||
ASSERT (reason != NULL && expression != NULL);
|
||||
lf_printf (file, " /* %s - %s */\n", reason, expression);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
print_icache_body (lf *file,
|
||||
insn_entry *instruction,
|
||||
opcode_bits *expanded_bits,
|
||||
cache_entry *cache_rules,
|
||||
icache_decl_type what_to_declare,
|
||||
icache_body_type what_to_do,
|
||||
int nr_prefetched_words)
|
||||
{
|
||||
/* extract instruction fields */
|
||||
lf_printf (file, "/* Extraction: %s\n", instruction->name);
|
||||
lf_printf (file, " ");
|
||||
switch (what_to_declare)
|
||||
{
|
||||
case define_variables:
|
||||
lf_printf (file, "#define");
|
||||
break;
|
||||
case declare_variables:
|
||||
lf_printf (file, "declare");
|
||||
break;
|
||||
case undef_variables:
|
||||
lf_printf (file, "#undef");
|
||||
break;
|
||||
}
|
||||
lf_printf (file, " ");
|
||||
switch (what_to_do)
|
||||
{
|
||||
case get_values_from_icache:
|
||||
lf_printf (file, "get-values-from-icache");
|
||||
break;
|
||||
case put_values_in_icache:
|
||||
lf_printf (file, "put-values-in-icache");
|
||||
break;
|
||||
case both_values_and_icache:
|
||||
lf_printf (file, "get-values-from-icache|put-values-in-icache");
|
||||
break;
|
||||
case do_not_use_icache:
|
||||
lf_printf (file, "do-not-use-icache");
|
||||
break;
|
||||
}
|
||||
lf_printf (file, "\n ");
|
||||
print_insn_words (file, instruction);
|
||||
lf_printf(file, " */\n");
|
||||
|
||||
/* pass zero - fetch from memory any missing instructions.
|
||||
|
||||
Some of the instructions will have already been fetched (in the
|
||||
instruction array), others will still need fetching. */
|
||||
switch (what_to_do)
|
||||
{
|
||||
case get_values_from_icache:
|
||||
break;
|
||||
case put_values_in_icache:
|
||||
case both_values_and_icache:
|
||||
case do_not_use_icache:
|
||||
{
|
||||
int word_nr;
|
||||
switch (what_to_declare)
|
||||
{
|
||||
case undef_variables:
|
||||
break;
|
||||
case define_variables:
|
||||
case declare_variables:
|
||||
for (word_nr = nr_prefetched_words;
|
||||
word_nr < instruction->nr_words;
|
||||
word_nr++)
|
||||
{
|
||||
/* FIXME - should be using print_icache_extraction? */
|
||||
lf_printf (file, "%sinstruction_word instruction_%d UNUSED = ",
|
||||
options.module.global.prefix.l,
|
||||
word_nr);
|
||||
lf_printf (file, "IMEM%d_IMMED (cia, %d)",
|
||||
options.insn_bit_size, word_nr);
|
||||
lf_printf (file, ";\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* if putting the instruction words in the cache, define references
|
||||
for them */
|
||||
if (options.gen.insn_in_icache) {
|
||||
/* FIXME: is the instruction_word type correct? */
|
||||
print_icache_extraction (file,
|
||||
instruction->format_name,
|
||||
cache_value,
|
||||
"insn", /* name */
|
||||
"instruction_word", /* type */
|
||||
"instruction", /* expression */
|
||||
NULL, /* origin */
|
||||
NULL, /* line */
|
||||
NULL, NULL,
|
||||
what_to_declare,
|
||||
what_to_do);
|
||||
}
|
||||
lf_printf(file, "\n");
|
||||
|
||||
/* pass one - process instruction fields.
|
||||
|
||||
If there is no cache rule, the default is to enter the field into
|
||||
the cache */
|
||||
{
|
||||
insn_word_entry *word;
|
||||
for (word = instruction->words;
|
||||
word != NULL;
|
||||
word = word->next)
|
||||
{
|
||||
insn_field_entry *cur_field;
|
||||
for (cur_field = word->first;
|
||||
cur_field->first < options.insn_bit_size;
|
||||
cur_field = cur_field->next)
|
||||
{
|
||||
if (cur_field->type == insn_field_string)
|
||||
{
|
||||
cache_entry *cache_rule;
|
||||
cache_entry_type value_type = cache_value;
|
||||
line_ref *value_line = instruction->line;
|
||||
/* check the cache table to see if it contains a rule
|
||||
overriding the default cache action for an
|
||||
instruction field */
|
||||
for (cache_rule = cache_rules;
|
||||
cache_rule != NULL;
|
||||
cache_rule = cache_rule->next)
|
||||
{
|
||||
if (filter_is_subset (instruction->field_names,
|
||||
cache_rule->original_fields)
|
||||
&& strcmp (cache_rule->name, cur_field->val_string) == 0)
|
||||
{
|
||||
value_type = cache_rule->entry_type;
|
||||
value_line = cache_rule->line;
|
||||
if (value_type == compute_value)
|
||||
{
|
||||
options.warning (cache_rule->line,
|
||||
"instruction field of type `compute' changed to `cache'\n");
|
||||
cache_rule->entry_type = cache_value;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
/* Define an entry for the field within the
|
||||
instruction */
|
||||
print_icache_extraction (file,
|
||||
instruction->format_name,
|
||||
value_type,
|
||||
cur_field->val_string, /* name */
|
||||
NULL, /* type */
|
||||
NULL, /* expression */
|
||||
cur_field->val_string, /* insn field */
|
||||
value_line,
|
||||
cur_field,
|
||||
expanded_bits,
|
||||
what_to_declare,
|
||||
what_to_do);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* pass two - any cache fields not processed above */
|
||||
{
|
||||
cache_entry *cache_rule;
|
||||
for (cache_rule = cache_rules;
|
||||
cache_rule != NULL;
|
||||
cache_rule = cache_rule->next)
|
||||
{
|
||||
if (filter_is_subset (instruction->field_names,
|
||||
cache_rule->original_fields)
|
||||
&& !filter_is_member (instruction->field_names,
|
||||
cache_rule->name))
|
||||
{
|
||||
char *single_field = filter_next (cache_rule->original_fields, "");
|
||||
if (filter_next (cache_rule->original_fields, single_field) != NULL)
|
||||
single_field = NULL;
|
||||
print_icache_extraction (file,
|
||||
instruction->format_name,
|
||||
cache_rule->entry_type,
|
||||
cache_rule->name,
|
||||
cache_rule->type,
|
||||
cache_rule->expression,
|
||||
single_field,
|
||||
cache_rule->line,
|
||||
NULL, /* cur_field */
|
||||
expanded_bits,
|
||||
what_to_declare,
|
||||
what_to_do);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lf_print__internal_ref (file);
|
||||
}
|
||||
|
||||
|
||||
|
||||
typedef struct _form_fields form_fields;
|
||||
struct _form_fields {
|
||||
char *name;
|
||||
filter *fields;
|
||||
form_fields *next;
|
||||
};
|
||||
|
||||
static form_fields *
|
||||
insn_table_cache_fields (insn_table *isa)
|
||||
{
|
||||
form_fields *forms = NULL;
|
||||
insn_entry *insn;
|
||||
for (insn = isa->insns;
|
||||
insn != NULL;
|
||||
insn = insn->next) {
|
||||
form_fields **form = &forms;
|
||||
while (1)
|
||||
{
|
||||
if (*form == NULL)
|
||||
{
|
||||
/* new format name, add it */
|
||||
form_fields *new_form = ZALLOC (form_fields);
|
||||
new_form->name = insn->format_name;
|
||||
filter_add (&new_form->fields, insn->field_names);
|
||||
*form = new_form;
|
||||
break;
|
||||
}
|
||||
else if (strcmp ((*form)->name, insn->format_name) == 0)
|
||||
{
|
||||
/* already present, add field names to the existing list */
|
||||
filter_add (&(*form)->fields, insn->field_names);
|
||||
break;
|
||||
}
|
||||
form = &(*form)->next;
|
||||
}
|
||||
}
|
||||
return forms;
|
||||
}
|
||||
|
||||
|
||||
|
||||
extern void
|
||||
print_icache_struct (lf *file,
|
||||
insn_table *isa,
|
||||
cache_entry *cache_rules)
|
||||
{
|
||||
/* Create a list of all the different instruction formats with their
|
||||
corresponding field names. */
|
||||
form_fields *formats = insn_table_cache_fields (isa);
|
||||
|
||||
lf_printf (file, "\n");
|
||||
lf_printf (file, "#define WITH_%sIDECODE_CACHE_SIZE %d\n",
|
||||
options.module.global.prefix.u,
|
||||
(options.gen.icache ? options.gen.icache_size : 0));
|
||||
lf_printf (file, "\n");
|
||||
|
||||
/* create an instruction cache if being used */
|
||||
if (options.gen.icache) {
|
||||
lf_printf (file, "typedef struct _%sidecode_cache {\n",
|
||||
options.module.global.prefix.l);
|
||||
lf_indent (file, +2);
|
||||
{
|
||||
form_fields *format;
|
||||
lf_printf (file, "unsigned_word address;\n");
|
||||
lf_printf (file, "void *semantic;\n");
|
||||
lf_printf (file, "union {\n");
|
||||
lf_indent (file, +2);
|
||||
for (format = formats;
|
||||
format != NULL;
|
||||
format = format->next)
|
||||
{
|
||||
lf_printf (file, "struct {\n");
|
||||
lf_indent (file, +2);
|
||||
{
|
||||
cache_entry *cache_rule;
|
||||
char *field;
|
||||
/* space for any instruction words */
|
||||
if (options.gen.insn_in_icache)
|
||||
lf_printf (file, "instruction_word insn[%d];\n", isa->max_nr_words);
|
||||
/* define an entry for any applicable cache rules */
|
||||
for (cache_rule = cache_rules;
|
||||
cache_rule != NULL;
|
||||
cache_rule = cache_rule->next)
|
||||
{
|
||||
/* nb - sort of correct - should really check against
|
||||
individual instructions */
|
||||
if (filter_is_subset (format->fields, cache_rule->original_fields))
|
||||
{
|
||||
char *memb;
|
||||
lf_printf (file, "%s %s;",
|
||||
(cache_rule->type == NULL
|
||||
? "unsigned"
|
||||
: cache_rule->type),
|
||||
cache_rule->name);
|
||||
lf_printf (file, " /*");
|
||||
for (memb = filter_next (cache_rule->original_fields, "");
|
||||
memb != NULL;
|
||||
memb = filter_next (cache_rule->original_fields, memb))
|
||||
{
|
||||
lf_printf (file, " %s", memb);
|
||||
}
|
||||
lf_printf (file, " */\n");
|
||||
}
|
||||
}
|
||||
/* define an entry for any fields not covered by a cache rule */
|
||||
for (field = filter_next (format->fields, "");
|
||||
field != NULL;
|
||||
field = filter_next (format->fields, field))
|
||||
{
|
||||
cache_entry *cache_rule;
|
||||
int found_rule = 0;
|
||||
for (cache_rule = cache_rules;
|
||||
cache_rule != NULL;
|
||||
cache_rule = cache_rule->next)
|
||||
{
|
||||
if (strcmp (cache_rule->name, field) == 0)
|
||||
{
|
||||
found_rule = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found_rule)
|
||||
lf_printf (file, "unsigned %s; /* default */\n", field);
|
||||
}
|
||||
}
|
||||
lf_indent (file, -2);
|
||||
lf_printf (file, "} %s;\n", format->name);
|
||||
}
|
||||
lf_indent (file, -2);
|
||||
lf_printf (file, "} crack;\n");
|
||||
}
|
||||
lf_indent (file, -2);
|
||||
lf_printf (file, "} %sidecode_cache;\n", options.module.global.prefix.l);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* alernativly, since no cache, emit a dummy definition for
|
||||
idecode_cache so that code refering to the type can still compile */
|
||||
lf_printf(file, "typedef void %sidecode_cache;\n",
|
||||
options.module.global.prefix.l);
|
||||
}
|
||||
lf_printf (file, "\n");
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void
|
||||
print_icache_function (lf *file,
|
||||
insn_entry *instruction,
|
||||
opcode_bits *expanded_bits,
|
||||
insn_opcodes *opcodes,
|
||||
cache_entry *cache_rules,
|
||||
int nr_prefetched_words)
|
||||
{
|
||||
int indent;
|
||||
|
||||
/* generate code to enter decoded instruction into the icache */
|
||||
lf_printf(file, "\n");
|
||||
lf_print__function_type_function (file, print_icache_function_type,
|
||||
"EXTERN_ICACHE", "\n");
|
||||
indent = print_function_name (file,
|
||||
instruction->name,
|
||||
instruction->format_name,
|
||||
NULL,
|
||||
expanded_bits,
|
||||
function_name_prefix_icache);
|
||||
indent += lf_printf (file, " ");
|
||||
lf_indent (file, +indent);
|
||||
lf_printf (file, "(");
|
||||
print_icache_function_formal (file, nr_prefetched_words);
|
||||
lf_printf (file, ")\n");
|
||||
lf_indent (file, -indent);
|
||||
|
||||
/* function header */
|
||||
lf_printf (file, "{\n");
|
||||
lf_indent (file, +2);
|
||||
|
||||
print_my_defines (file,
|
||||
instruction->name,
|
||||
instruction->format_name,
|
||||
expanded_bits);
|
||||
print_itrace (file, instruction, 1/*putting-value-in-cache*/);
|
||||
|
||||
print_idecode_validate (file, instruction, opcodes);
|
||||
|
||||
lf_printf (file, "\n");
|
||||
lf_printf (file, "{\n");
|
||||
lf_indent (file, +2);
|
||||
if (options.gen.semantic_icache)
|
||||
lf_printf (file, "unsigned_word nia;\n");
|
||||
print_icache_body (file,
|
||||
instruction,
|
||||
expanded_bits,
|
||||
cache_rules,
|
||||
(options.gen.direct_access
|
||||
? define_variables
|
||||
: declare_variables),
|
||||
(options.gen.semantic_icache
|
||||
? both_values_and_icache
|
||||
: put_values_in_icache),
|
||||
nr_prefetched_words);
|
||||
|
||||
lf_printf (file, "\n");
|
||||
lf_printf (file, "cache_entry->address = cia;\n");
|
||||
lf_printf (file, "cache_entry->semantic = ");
|
||||
print_function_name (file,
|
||||
instruction->name,
|
||||
instruction->format_name,
|
||||
NULL,
|
||||
expanded_bits,
|
||||
function_name_prefix_semantics);
|
||||
lf_printf (file, ";\n");
|
||||
lf_printf (file, "\n");
|
||||
|
||||
if (options.gen.semantic_icache) {
|
||||
lf_printf (file, "/* semantic routine */\n");
|
||||
print_semantic_body (file,
|
||||
instruction,
|
||||
expanded_bits,
|
||||
opcodes);
|
||||
lf_printf (file, "return nia;\n");
|
||||
}
|
||||
|
||||
if (!options.gen.semantic_icache)
|
||||
{
|
||||
lf_printf (file, "/* return the function proper */\n");
|
||||
lf_printf (file, "return ");
|
||||
print_function_name (file,
|
||||
instruction->name,
|
||||
instruction->format_name,
|
||||
NULL,
|
||||
expanded_bits,
|
||||
function_name_prefix_semantics);
|
||||
lf_printf (file, ";\n");
|
||||
}
|
||||
|
||||
if (options.gen.direct_access)
|
||||
{
|
||||
print_icache_body (file,
|
||||
instruction,
|
||||
expanded_bits,
|
||||
cache_rules,
|
||||
undef_variables,
|
||||
(options.gen.semantic_icache
|
||||
? both_values_and_icache
|
||||
: put_values_in_icache),
|
||||
nr_prefetched_words);
|
||||
}
|
||||
|
||||
lf_indent (file, -2);
|
||||
lf_printf (file, "}\n");
|
||||
lf_indent (file, -2);
|
||||
lf_printf (file, "}\n");
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
print_icache_definition (lf *file,
|
||||
insn_entry *insn,
|
||||
opcode_bits *expanded_bits,
|
||||
insn_opcodes *opcodes,
|
||||
cache_entry *cache_rules,
|
||||
int nr_prefetched_words)
|
||||
{
|
||||
print_icache_function (file,
|
||||
insn,
|
||||
expanded_bits,
|
||||
opcodes,
|
||||
cache_rules,
|
||||
nr_prefetched_words);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
print_icache_internal_function_declaration (lf *file,
|
||||
function_entry *function,
|
||||
void *data)
|
||||
{
|
||||
ASSERT (options.gen.icache);
|
||||
if (function->is_internal)
|
||||
{
|
||||
lf_printf (file, "\n");
|
||||
lf_print__function_type_function (file, print_icache_function_type,
|
||||
"INLINE_ICACHE", "\n");
|
||||
print_function_name (file,
|
||||
function->name,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
function_name_prefix_icache);
|
||||
lf_printf (file, "\n(");
|
||||
print_icache_function_formal (file, 0);
|
||||
lf_printf (file, ");\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
print_icache_internal_function_definition (lf *file,
|
||||
function_entry *function,
|
||||
void *data)
|
||||
{
|
||||
ASSERT (options.gen.icache);
|
||||
if (function->is_internal)
|
||||
{
|
||||
lf_printf (file, "\n");
|
||||
lf_print__function_type_function (file, print_icache_function_type,
|
||||
"INLINE_ICACHE", "\n");
|
||||
print_function_name (file,
|
||||
function->name,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
function_name_prefix_icache);
|
||||
lf_printf (file, "\n(");
|
||||
print_icache_function_formal (file, 0);
|
||||
lf_printf (file, ")\n");
|
||||
lf_printf (file, "{\n");
|
||||
lf_indent (file, +2);
|
||||
lf_printf (file, "/* semantic routine */\n");
|
||||
if (options.gen.semantic_icache)
|
||||
{
|
||||
lf_print__line_ref (file, function->code->line);
|
||||
table_print_code (file, function->code);
|
||||
lf_printf (file, "error (\"Internal function must longjump\\n\");\n");
|
||||
lf_printf (file, "return 0;\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
lf_printf (file, "return ");
|
||||
print_function_name (file,
|
||||
function->name,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
function_name_prefix_semantics);
|
||||
lf_printf (file, ";\n");
|
||||
}
|
||||
|
||||
lf_print__internal_ref (file);
|
||||
lf_indent (file, -2);
|
||||
lf_printf (file, "}\n");
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user