* filter.c: Re-indent.
* filter.h, filter_host.h, gen-engine.c, gen-engine.h: Ditto.
* gen-icache.c, gen-icache.h, gen-idecode.c: Ditto.
* gen-idecode.h, gen-itable.c, gen-itable.h: Ditto.
* gen-model.c, gen-model.h, gen-semantics.c: Ditto.
* gen-semantics.h, gen-support.c, gen-support.h: Ditto.
* gen.c, gen.h, igen.c, igen.h, ld-cache.c, ld-cache.h: Ditto.
* ld-decode.c, ld-decode.h, ld-insn.c, ld-insn.h, lf.c: Ditto.
* lf.h, misc.c, misc.h, table.c, table.h: Ditto.
+2002-11-21 Andrew Cagney <ac131313@redhat.com>
+
+ * filter.c: Re-indent.
+ * filter.h, filter_host.h, gen-engine.c, gen-engine.h: Ditto.
+ * gen-icache.c, gen-icache.h, gen-idecode.c: Ditto.
+ * gen-idecode.h, gen-itable.c, gen-itable.h: Ditto.
+ * gen-model.c, gen-model.h, gen-semantics.c: Ditto.
+ * gen-semantics.h, gen-support.c, gen-support.h: Ditto.
+ * gen.c, gen.h, igen.c, igen.h, ld-cache.c, ld-cache.h: Ditto.
+ * ld-decode.c, ld-decode.h, ld-insn.c, ld-insn.h, lf.c: Ditto.
+ * lf.h, misc.c, misc.h, table.c, table.h: Ditto.
+
2002-11-21 Andrew Cagney <ac131313@redhat.com>
* Makefile.in: Update copyright. IGEN contributed to the FSF.
#include "lf.h"
#include "filter.h"
-struct _filter {
+struct _filter
+{
char *member;
filter *next;
};
void
-filter_parse (filter **filters,
- const char *filt)
+filter_parse (filter **filters, const char *filt)
{
while (strlen (filt) > 0)
{
filter **last;
/* break out a member of the filter list */
const char *flag = filt;
- unsigned /*size_t*/ len;
+ unsigned /*size_t */ len;
filt = strchr (filt, ',');
if (filt == NULL)
{
}
/* find an insertion point - sorted order */
last = filters;
- while (*last != NULL
- && strncmp (flag, (*last)->member, len) > 0)
+ while (*last != NULL && strncmp (flag, (*last)->member, len) > 0)
last = &(*last)->next;
if (*last != NULL
&& strncmp (flag, (*last)->member, len) == 0
&& strlen ((*last)->member) == len)
- continue; /* duplicate */
+ continue; /* duplicate */
/* create an entry for that member */
new_filter = ZALLOC (filter);
new_filter->member = NZALLOC (char, len + 1);
void
-filter_add (filter **set,
- filter *add)
+filter_add (filter **set, filter *add)
{
while (add != NULL)
{
int cmp;
if (*set == NULL)
- cmp = 1; /* set->member > add->member */
+ cmp = 1; /* set->member > add->member */
else
cmp = strcmp ((*set)->member, add->member);
if (cmp > 0)
/* already in set */
add = add->next;
}
- else /* cmp < 0 */
+ else /* cmp < 0 */
{
/* not reached insertion point */
set = &(*set)->next;
int
-filter_is_subset (filter *superset,
- filter *subset)
+filter_is_subset (filter *superset, filter *subset)
{
while (1)
{
if (subset == NULL)
return 1;
if (superset == NULL)
- return 0; /* subset isn't finished */
+ return 0; /* subset isn't finished */
cmp = strcmp (subset->member, superset->member);
if (cmp < 0)
- return 0; /* not found */
+ return 0; /* not found */
else if (cmp == 0)
- subset = subset->next; /* found */
+ subset = subset->next; /* found */
else if (cmp > 0)
- superset = superset->next; /* later in list? */
+ superset = superset->next; /* later in list? */
}
}
int
-filter_is_common (filter *l,
- filter *r)
+filter_is_common (filter *l, filter *r)
{
while (1)
{
if (cmp < 0)
l = l->next;
else if (cmp == 0)
- return 1; /* common member */
+ return 1; /* common member */
else if (cmp > 0)
r = r->next;
}
int
-filter_is_member (filter *filt,
- const char *flag)
+filter_is_member (filter *filt, const char *flag)
{
int index = 1;
while (filt != NULL)
int
-is_filtered_out (filter *filters,
- const char *flags)
+is_filtered_out (filter *filters, const char *flags)
{
- while (strlen(flags) > 0) {
- int present;
- filter *filt = filters;
- /* break the string up */
- char *end = strchr(flags, ',');
- char *next;
- unsigned /*size_t*/ len;
- if (end == NULL) {
- end = strchr(flags, '\0');
- next = end;
- }
- else {
- next = end + 1;
- }
- len = end - flags;
- /* check that it is present */
- present = 0;
- filt = filters;
- while (filt != NULL) {
- if (strncmp(flags, filt->member, len) == 0
- && strlen(filt->member) == len) {
- present = 1;
- break;
- }
- filt = filt->next;
+ while (strlen (flags) > 0)
+ {
+ int present;
+ filter *filt = filters;
+ /* break the string up */
+ char *end = strchr (flags, ',');
+ char *next;
+ unsigned /*size_t */ len;
+ if (end == NULL)
+ {
+ end = strchr (flags, '\0');
+ next = end;
+ }
+ else
+ {
+ next = end + 1;
+ }
+ len = end - flags;
+ /* check that it is present */
+ present = 0;
+ filt = filters;
+ while (filt != NULL)
+ {
+ if (strncmp (flags, filt->member, len) == 0
+ && strlen (filt->member) == len)
+ {
+ present = 1;
+ break;
+ }
+ filt = filt->next;
+ }
+ if (!present)
+ return 1;
+ flags = next;
}
- if (!present)
- return 1;
- flags = next;
- }
return 0;
}
#if 0
int
-it_is (const char *flag,
- const char *flags)
+it_is (const char *flag, const char *flags)
{
- int flag_len = strlen(flag);
- while (*flags != '\0') {
- if (!strncmp(flags, flag, flag_len)
- && (flags[flag_len] == ',' || flags[flag_len] == '\0'))
- return 1;
- while (*flags != ',') {
- if (*flags == '\0')
- return 0;
+ int flag_len = strlen (flag);
+ while (*flags != '\0')
+ {
+ if (!strncmp (flags, flag, flag_len)
+ && (flags[flag_len] == ',' || flags[flag_len] == '\0'))
+ return 1;
+ while (*flags != ',')
+ {
+ if (*flags == '\0')
+ return 0;
+ flags++;
+ }
flags++;
}
- flags++;
- }
return 0;
}
#endif
char *
-filter_next (filter *set,
- char *member)
+filter_next (filter *set, char *member)
{
while (set != NULL)
{
void
-dump_filter (lf *file,
- char *prefix,
- filter *set,
- char *suffix)
+dump_filter (lf *file, char *prefix, filter *set, char *suffix)
{
char *member;
lf_printf (file, "%s", prefix);
#ifdef MAIN
int
-main(int argc, char **argv)
+main (int argc, char **argv)
{
filter *subset = NULL;
filter *superset = NULL;
lf *l;
int i;
- if (argc < 2) {
- printf("Usage: filter <subset> <filter> ...\n");
- exit (1);
- }
+ if (argc < 2)
+ {
+ printf ("Usage: filter <subset> <filter> ...\n");
+ exit (1);
+ }
/* load the filter up */
filter_parse (&subset, argv[1]);
- for (i = 2; i < argc; i++)
+ for (i = 2; i < argc; i++)
filter_parse (&superset, argv[i]);
/* dump various info */
dump_filter (l, "{", superset, " }");
lf_printf (l, "\n");
}
-
+
return 0;
}
#endif
/* parse the list merging any flags into the filter */
-extern void filter_parse
-(filter **filters,
- const char *filt);
+extern void filter_parse (filter **filters, const char *filt);
/* add the second filter to the first */
-extern void filter_add
-(filter **filters,
- filter *add);
+extern void filter_add (filter **filters, filter *add);
/* returns true if SUB is a strict subset of SUPER. For an empty set
is a member of any set */
-extern int filter_is_subset
-(filter *superset,
- filter *subset);
+extern int filter_is_subset (filter *superset, filter *subset);
/* return true if there is at least one member common to the two
filters */
-extern int filter_is_common
-(filter *l,
- filter *r);
+extern int filter_is_common (filter *l, filter *r);
/* returns the index (pos + 1) if the name is in the filter. */
-extern int filter_is_member
-(filter *set,
- const char *flag);
+extern int filter_is_member (filter *set, const char *flag);
/* returns true if one of the flags is not present in the filter.
=== !filter_is_subset (filter_parse (NULL, flags), filters) */
-int is_filtered_out
-(filter *filters,
- const char *flags);
+int is_filtered_out (filter *filters, const char *flags);
/* returns the next member of the filter set that follows MEMBER.
Member does not need to be an elememt of the filter set. Next of
"" is the first non-empty member */
-char *filter_next
-(filter *set,
- char *member);
+char *filter_next (filter *set, char *member);
/* for debugging */
-extern void dump_filter
-(lf *file,
- char *prefix,
- filter *filt,
- char *suffix);
+extern void dump_filter (lf *file, char *prefix, filter *filt, char *suffix);
#define _FILTER_HOST_H
/* Remove directory part from filename */
-extern const char *
-filter_filename(const char *filename);
+extern const char *filter_filename (const char *filename);
#endif
static void
-print_run_body (lf *file,
- gen_entry *table)
+print_run_body (lf *file, gen_entry *table)
{
/* Output the function to execute real code:
-
+
Unfortunatly, there are multiple cases to consider vis:
-
+
<icache> X <smp>
-
+
Consequently this function is written in multiple different ways */
-
+
lf_printf (file, "{\n");
lf_indent (file, +2);
if (!options.gen.smp)
{
- lf_printf (file, "%sinstruction_address cia;\n", options.module.global.prefix.l);
+ lf_printf (file, "%sinstruction_address cia;\n",
+ options.module.global.prefix.l);
}
lf_printf (file, "int current_cpu = next_cpu_nr;\n");
-
+
if (options.gen.icache)
{
lf_printf (file, "/* flush the icache of a possible break insn */\n");
lf_printf (file, " cpu_flush_icache (STATE_CPU (sd, cpu_nr));\n");
lf_printf (file, "}\n");
}
-
+
if (!options.gen.smp)
{
-
+
lf_putstr (file, "\
/* CASE 1: NO SMP (with or with out instruction cache).\n\
\n\
lf_putstr (file, "while (1)\n");
lf_putstr (file, " {\n");
lf_indent (file, +4);
-
+
lf_printf (file, "%sinstruction_address nia;\n",
options.module.global.prefix.l);
lf_printf (file, "\n");
if (!options.gen.icache)
{
- lf_printf (file, "%sinstruction_word instruction_0 = IMEM%d (cia);\n",
- options.module.global.prefix.l,
- options.insn_bit_size);
+ lf_printf (file,
+ "%sinstruction_word instruction_0 = IMEM%d (cia);\n",
+ options.module.global.prefix.l, options.insn_bit_size);
print_engine_issue_prefix_hook (file);
print_idecode_body (file, table, "nia = ");
print_engine_issue_postfix_hook (file);
lf_putstr (file, " {\n");
lf_indent (file, -4);
lf_putstr (file, "/* cache hit */\n");
- lf_putstr (file, "idecode_semantic *const semantic = cache_entry->semantic;\n");
+ lf_putstr (file,
+ "idecode_semantic *const semantic = cache_entry->semantic;\n");
lf_putstr (file, "cia = semantic (cpu, cache_entry, cia);\n");
/* tail */
lf_indent (file, -4);
lf_printf (file, "instruction_word instruction = IMEM%d (cia);\n",
options.insn_bit_size);
lf_putstr (file, "if (WITH_MON != 0)\n");
- lf_putstr (file, " mon_event (mon_event_icache_miss, cpu, cia);\n");
+ lf_putstr (file,
+ " mon_event (mon_event_icache_miss, cpu, cia);\n");
if (options.gen.semantic_icache)
{
lf_putstr (file, "{\n");
lf_indent (file, -4);
lf_putstr (file, " }\n");
}
-
+
/* update the cpu if necessary */
switch (options.gen.nia)
{
lf_indent (file, -4);
lf_printf (file, " }\n");
}
-
+
if (options.gen.smp)
{
-
+
lf_putstr (file, "\
/* CASE 2: SMP (With or without ICACHE)\n\
\n\
after all the other CPU's and the event queue have been processed */\n\
\n\
");
-
+
lf_putstr (file, "\n");
- lf_printf (file, "/* have ensured that the event queue is NOT next */\n");
+ lf_printf (file,
+ "/* have ensured that the event queue is NOT next */\n");
lf_printf (file, "SIM_ASSERT (current_cpu >= 0);\n");
lf_printf (file, "SIM_ASSERT (current_cpu <= nr_cpus - 1);\n");
lf_printf (file, "SIM_ASSERT (nr_cpus <= MAX_NR_PROCESSORS);\n");
lf_putstr (file, "CIA_SET (cpu, cia);\n");
print_engine_issue_postfix_hook (file);
}
-
+
if (options.gen.icache)
{
lf_putstr (file, "engine_cache *cache_entry =\n");
lf_indent (file, +2);
lf_putstr (file, "\n");
lf_putstr (file, "/* cache hit */\n");
- lf_putstr (file, "engine_semantic *semantic = cache_entry->semantic;\n");
- lf_putstr (file, "cia = semantic(processor, cache_entry, cia);\n");
+ lf_putstr (file,
+ "engine_semantic *semantic = cache_entry->semantic;\n");
+ lf_putstr (file,
+ "cia = semantic(processor, cache_entry, cia);\n");
/* tail */
lf_putstr (file, "cpu_set_program_counter(processor, cia);\n");
lf_putstr (file, "\n");
lf_printf (file, "instruction_word instruction = IMEM%d (cia);\n",
options.insn_bit_size);
lf_putstr (file, "if (WITH_MON != 0)\n");
- lf_putstr (file, " mon_event(mon_event_icache_miss, processors[current_cpu], cia);\n");
+ lf_putstr (file,
+ " mon_event(mon_event_icache_miss, processors[current_cpu], cia);\n");
if (options.gen.semantic_icache)
{
lf_putstr (file, "{\n");
lf_indent (file, +2);
print_engine_issue_prefix_hook (file);
- print_idecode_body(file, table, "cia =");
+ print_idecode_body (file, table, "cia =");
print_engine_issue_postfix_hook (file);
lf_indent (file, -2);
lf_putstr (file, "}\n");
else
{
print_engine_issue_prefix_hook (file);
- print_idecode_body(file, table, "semantic = ");
- lf_putstr (file, "cia = semantic(processor, cache_entry, cia);\n");
+ print_idecode_body (file, table, "semantic = ");
+ lf_putstr (file,
+ "cia = semantic(processor, cache_entry, cia);\n");
print_engine_issue_postfix_hook (file);
}
/* tail */
}
lf_putstr (file, "}\n");
}
-
+
lf_putstr (file, "\n");
lf_putstr (file, "current_cpu += 1;\n");
lf_putstr (file, "if (current_cpu == nr_cpus)\n");
lf_putstr (file, " }\n");
lf_putstr (file, " current_cpu = 0;\n");
lf_putstr (file, " }\n");
-
+
/* tail */
lf_indent (file, -4);
lf_putstr (file, " }\n");
}
-
-
+
+
lf_indent (file, -2);
lf_putstr (file, "}\n");
}
#if 0
static void
-print_jump (lf *file,
- int is_tail)
+print_jump (lf *file, int is_tail)
{
if (!options.gen.smp)
{
lf_putstr (file, " }\n");
lf_putstr (file, "}\n");
}
-
+
if (options.gen.smp)
{
if (is_tail)
lf_putstr (file, "processor = processors[current_cpu];\n");
lf_putstr (file, "nia = cpu_get_program_counter(processor);\n");
}
-
+
if (options.gen.icache)
{
lf_putstr (file, "cache_entry = cpu_icache_entry(processor, nia);\n");
lf_putstr (file, " /* cache hit */\n");
lf_putstr (file, " goto *cache_entry->semantic;\n");
lf_putstr (file, "}\n");
- if (is_tail) {
- lf_putstr (file, "goto cache_miss;\n");
- }
+ if (is_tail)
+ {
+ lf_putstr (file, "goto cache_miss;\n");
+ }
}
-
+
if (!options.gen.icache && is_tail)
{
lf_printf (file, "goto engine;\n");
}
-
+
}
#endif
#if 0
static void
print_jump_insn (lf *file,
- insn_entry *instruction,
+ insn_entry * instruction,
opcode_bits *expanded_bits,
- opcode_field *opcodes,
- cache_entry *cache_rules)
+ opcode_field *opcodes, cache_entry *cache_rules)
{
insn_opcodes opcode_path;
lf_printf (file, "\n");
print_my_defines (file,
instruction->name,
- instruction->format_name,
- expanded_bits);
-
+ instruction->format_name, expanded_bits);
+
/* output the icache entry */
if (options.gen.icache)
{
print_function_name (file,
instruction->name,
instruction->format_name,
- NULL,
- expanded_bits,
- function_name_prefix_icache);
+ NULL, expanded_bits, function_name_prefix_icache);
lf_printf (file, ":\n");
lf_indent (file, +1);
lf_printf (file, "{\n");
lf_indent (file, +2);
lf_putstr (file, "const unsigned_word cia = nia;\n");
- print_itrace (file, instruction, 1/*putting-value-in-cache*/);
+ print_itrace (file, instruction, 1 /*putting-value-in-cache */ );
print_idecode_validate (file, instruction, &opcode_path);
lf_printf (file, "\n");
lf_printf (file, "{\n");
lf_indent (file, +2);
- print_icache_body (file,
- instruction,
- expanded_bits,
- cache_rules,
- 0, /*use_defines*/
+ print_icache_body (file, instruction, expanded_bits, cache_rules, 0, /*use_defines */
put_values_in_icache);
lf_printf (file, "cache_entry->address = nia;\n");
lf_printf (file, "cache_entry->semantic = &&");
instruction->name,
instruction->format_name,
NULL,
- expanded_bits,
- function_name_prefix_semantics);
+ expanded_bits, function_name_prefix_semantics);
lf_printf (file, ";\n");
if (options.gen.semantic_icache)
{
print_semantic_body (file,
- instruction,
- expanded_bits,
- &opcode_path);
- print_jump(file, 1/*is-tail*/);
+ instruction, expanded_bits, &opcode_path);
+ print_jump (file, 1 /*is-tail */ );
}
else
{
instruction->name,
instruction->format_name,
NULL,
- expanded_bits,
- function_name_prefix_semantics);
+ expanded_bits, function_name_prefix_semantics);
lf_printf (file, "; */\n");
}
lf_indent (file, -2);
lf_indent (file, -2);
lf_printf (file, "}\n");
}
-
+
/* print the semantics */
lf_printf (file, "\n");
lf_indent (file, -1);
print_function_name (file,
instruction->name,
instruction->format_name,
- NULL,
- expanded_bits,
- function_name_prefix_semantics);
+ NULL, expanded_bits, function_name_prefix_semantics);
lf_printf (file, ":\n");
lf_indent (file, +1);
lf_printf (file, "{\n");
? define_variables
: declare_variables),
(options.gen.icache
- ? get_values_from_icache
- : do_not_use_icache));
- print_semantic_body (file,
- instruction,
- expanded_bits,
- &opcode_path);
+ ? get_values_from_icache : do_not_use_icache));
+ print_semantic_body (file, instruction, expanded_bits, &opcode_path);
if (options.gen.direct_access)
print_icache_body (file,
instruction,
cache_rules,
undef_variables,
(options.gen.icache
- ? get_values_from_icache
- : do_not_use_icache));
- print_jump(file, 1/*is tail*/);
+ ? get_values_from_icache : do_not_use_icache));
+ print_jump (file, 1 /*is tail */ );
lf_indent (file, -2);
lf_printf (file, "}\n");
}
#if 0
static void
-print_jump_definition (lf *file,
- gen_entry *entry,
- int depth,
- void *data)
+print_jump_definition (lf *file, gen_entry *entry, int depth, void *data)
{
- cache_entry *cache_rules = (cache_entry*)data;
+ cache_entry *cache_rules = (cache_entry *) data;
if (entry->opcode_rule->with_duplicates)
{
ASSERT (entry->nr_insns == 1
&& entry->opcode == NULL
- && entry->parent != NULL
- && entry->parent->opcode != NULL);
+ && entry->parent != NULL && entry->parent->opcode != NULL);
ASSERT (entry->nr_insns == 1
&& entry->opcode == NULL
&& entry->parent != NULL
&& entry->parent->opcode_rule != NULL);
print_jump_insn (file,
entry->insns->insn,
- entry->expanded_bits,
- entry->opcode,
- cache_rules);
+ entry->expanded_bits, entry->opcode, cache_rules);
}
- else
+ else
{
- print_jump_insn (file,
- entry->insns->insn,
- NULL,
- NULL,
- cache_rules);
+ print_jump_insn (file, entry->insns->insn, NULL, NULL, cache_rules);
}
}
#endif
#if 0
static void
-print_jump_internal_function (lf *file,
- function_entry *function,
- void *data)
+print_jump_internal_function (lf *file, function_entry * function, void *data)
{
if (function->is_internal)
{
#if 0
static void
print_jump_body (lf *file,
- gen_entry *entry,
- insn_table *isa,
- cache_entry *cache_rules)
+ gen_entry *entry, insn_table *isa, cache_entry *cache_rules)
{
lf_printf (file, "{\n");
lf_indent (file, +2);
{
lf_putstr (file, "int current_cpu = -1;\n");
}
-
+
/* all the switches and tables - they know about jumping */
print_idecode_lookups (file, entry, cache_rules);
-
+
/* start the simulation up */
if (options.gen.icache)
{
lf_putstr (file, " cpu_flush_icache(processors[cpu_nr]);\n");
lf_putstr (file, "}\n");
}
-
+
lf_putstr (file, "\n");
lf_putstr (file, "psim_set_halt_and_restart(system, &halt, &restart);\n");
-
+
lf_putstr (file, "\n");
lf_putstr (file, "if (setjmp(halt))\n");
lf_putstr (file, " return;\n");
-
+
lf_putstr (file, "\n");
lf_putstr (file, "setjmp(restart);\n");
-
+
lf_putstr (file, "\n");
if (!options.gen.smp)
{
{
lf_putstr (file, "current_cpu = psim_last_cpu(system);\n");
}
-
+
if (!options.gen.icache)
{
lf_printf (file, "\n");
lf_printf (file, "engine:\n");
lf_indent (file, +1);
}
-
- print_jump(file, 0/*is_tail*/);
-
+
+ print_jump (file, 0 /*is_tail */ );
+
if (options.gen.icache)
{
lf_indent (file, -1);
lf_printf (file, "cache_miss:\n");
lf_indent (file, +1);
}
-
- print_engine_issue_prefix_hook (file);
+
+ print_engine_issue_prefix_hook (file);
lf_putstr (file, "instruction\n");
- lf_putstr (file, " = vm_instruction_map_read(cpu_instruction_map(processor),\n");
+ lf_putstr (file,
+ " = vm_instruction_map_read(cpu_instruction_map(processor),\n");
lf_putstr (file, " processor, nia);\n");
print_engine_issue_prefix_hook (file);
print_idecode_body (file, entry, "/*IGORE*/");
print_engine_issue_postfix_hook (file);
-
+
/* print out a table of all the internals functions */
function_entry_traverse (file, isa->functions,
- print_jump_internal_function,
- NULL);
-
+ print_jump_internal_function, NULL);
+
/* print out a table of all the instructions */
ERROR ("Use the list of semantic functions, not travere_tree");
- gen_entry_traverse_tree (file, entry,
- 1,
- NULL, /* start */
- print_jump_definition, /* leaf */
- NULL, /* end */
+ gen_entry_traverse_tree (file, entry, 1, NULL, /* start */
+ print_jump_definition, /* leaf */
+ NULL, /* end */
cache_rules);
lf_indent (file, -2);
lf_printf (file, "}\n");
lf_printf (file, "void (*");
break;
}
- indent = print_function_name (file,
- "run",
- NULL, /* format name */
- processor,
- NULL, /* expanded bits */
+ indent = print_function_name (file, "run", NULL, /* format name */
+ processor, NULL, /* expanded bits */
function_name_prefix_engine);
switch (decl_type)
{
void
gen_engine_h (lf *file,
- gen_table *gen,
- insn_table *isa,
- cache_entry *cache_rules)
+ gen_table *gen, insn_table *isa, cache_entry *cache_rules)
{
gen_list *entry;
for (entry = gen->tables; entry != NULL; entry = entry->next)
print_engine_run_function_header (file,
(options.gen.multi_sim
? entry->model->name
- : NULL),
- is_function_declaration);
+ : NULL), is_function_declaration);
}
}
void
-gen_engine_c(lf *file,
- gen_table *gen,
- insn_table *isa,
- cache_entry *cache_rules)
+gen_engine_c (lf *file,
+ gen_table *gen, insn_table *isa, cache_entry *cache_rules)
{
gen_list *entry;
/* the intro */
{
case generate_calls:
print_idecode_lookups (file, entry->table, cache_rules);
-
+
/* output the main engine routine */
print_engine_run_function_header (file,
(options.gen.multi_sim
? entry->model->name
- : NULL),
- is_function_definition);
+ : NULL), is_function_definition);
print_run_body (file, entry->table);
break;
-
+
case generate_jumps:
ERROR ("Jumps currently unimplemented");
#if 0
print_engine_run_function_header (file,
entry->processor,
is_function_definition);
- print_jump_body (file, entry->table,
- isa, cache_rules);
+ print_jump_body (file, entry->table, isa, cache_rules);
#endif
break;
}
Boston, MA 02111-1307, USA. */
extern void gen_engine_h
-(lf *file,
- gen_table *gen,
- insn_table *isa,
- cache_entry *cache_rules);
+ (lf *file, gen_table *gen, insn_table *isa, cache_entry *cache_rules);
extern void gen_engine_c
-(lf *file,
- gen_table *gen,
- insn_table *isa,
- cache_entry *cache_rules);
+ (lf *file, gen_table *gen, insn_table *isa, cache_entry *cache_rules);
extern void print_engine_run_function_header
-(lf *file,
- char *processor,
- function_decl_type decl_type);
-
+ (lf *file, char *processor, function_decl_type decl_type);
int is_function_definition,
int nr_prefetched_words)
{
- lf_printf(file, "\n");
+ 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);
+ expanded_bits, function_name_prefix_icache);
lf_printf (file, "\n(");
print_icache_function_formal (file, nr_prefetched_words);
lf_printf (file, ")");
void
print_icache_declaration (lf *file,
- insn_entry *insn,
+ insn_entry * insn,
opcode_bits *expanded_bits,
- insn_opcodes *opcodes,
- int nr_prefetched_words)
+ insn_opcodes *opcodes, int nr_prefetched_words)
{
print_icache_function_header (file,
insn->name,
insn->format_name,
expanded_bits,
- 0/* is not function definition */,
+ 0 /* is not function definition */ ,
nr_prefetched_words);
}
char *reason;
ASSERT (format_name != NULL);
ASSERT (entry_name != NULL);
-
+
/* figure out exactly what should be going on here */
switch (cache_type)
{
{
reason = "cache";
what_to_declare = ((what_to_do & put_values_in_icache)
- ? declare_variables
- : what_to_declare);
+ ? declare_variables : what_to_declare);
}
else
return;
break;
default:
- abort (); /* Bad switch. */
+ abort (); /* Bad switch. */
}
-
+
/* 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)
+ 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)
{
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
{
/* 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).
-
+
+ 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";
"_is_",
strlen ("_is_")) == 0
&& ((bits->opcode->is_boolean
- && ((unsigned) atol (entry_name + strlen (single_insn_field) + strlen ("_is_"))
- == bits->opcode->boolean_constant))
+ && ((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. */
+ 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);
+ 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))),
+ (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)));
+ (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,
+ (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 */
+ 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? */
+ format_name, entry_name);
+ if (what_to_do & put_values_in_icache) /* also put it in the cache? */
{
lf_printf (file, " = ");
}
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);
+ 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,
}
}
}
-
+
switch (what_to_declare)
{
case define_variables:
void
print_icache_body (lf *file,
- insn_entry *instruction,
+ 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)
+ icache_body_type what_to_do, int nr_prefetched_words)
{
/* extract instruction fields */
lf_printf (file, "/* Extraction: %s\n", instruction->name);
}
lf_printf (file, "\n ");
print_insn_words (file, instruction);
- lf_printf(file, " */\n");
-
+ lf_printf (file, " */\n");
+
/* pass zero - fetch from memory any missing instructions.
Some of the instructions will have already been fetched (in the
case define_variables:
case declare_variables:
for (word_nr = nr_prefetched_words;
- word_nr < instruction->nr_words;
- word_nr++)
+ 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,
+ "%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");
+ 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.
the cache */
{
insn_word_entry *word;
- for (word = instruction->words;
- word != NULL;
- word = word->next)
+ for (word = instruction->words; word != NULL; word = word->next)
{
insn_field_entry *cur_field;
for (cur_field = word->first;
overriding the default cache action for an
instruction field */
for (cache_rule = cache_rules;
- cache_rule != NULL;
- cache_rule = cache_rule->next)
+ 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)
+ && strcmp (cache_rule->name,
+ cur_field->val_string) == 0)
{
value_type = cache_rule->entry_type;
value_line = cache_rule->line;
}
}
/* 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 */
+ 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);
+ what_to_declare, what_to_do);
}
}
}
{
cache_entry *cache_rule;
for (cache_rule = cache_rules;
- cache_rule != NULL;
- cache_rule = cache_rule->next)
+ 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))
+ && !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)
+ 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 */
+ 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);
+ what_to_declare, what_to_do);
}
}
}
typedef struct _form_fields form_fields;
-struct _form_fields {
+struct _form_fields
+{
char *name;
filter *fields;
form_fields *next;
{
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;
- }
- }
+ 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)
+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);
+ if (options.gen.icache)
{
- form_fields *format;
- lf_printf (file, "unsigned_word address;\n");
- lf_printf (file, "void *semantic;\n");
- lf_printf (file, "union {\n");
+ lf_printf (file, "typedef struct _%sidecode_cache {\n",
+ options.module.global.prefix.l);
lf_indent (file, +2);
- for (format = formats;
- format != NULL;
- format = format->next)
- {
- lf_printf (file, "struct {\n");
- 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)
{
- 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_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, "} %s;\n", format->name);
- }
+ lf_indent (file, -2);
+ lf_printf (file, "} crack;\n");
+ }
lf_indent (file, -2);
- lf_printf (file, "} crack;\n");
+ lf_printf (file, "} %sidecode_cache;\n",
+ options.module.global.prefix.l);
}
- 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);
+ 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,
+ insn_entry * instruction,
opcode_bits *expanded_bits,
insn_opcodes *opcodes,
- cache_entry *cache_rules,
- int nr_prefetched_words)
+ cache_entry *cache_rules, int nr_prefetched_words)
{
int indent;
/* generate code to enter decoded instruction into the icache */
- lf_printf(file, "\n");
+ 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);
+ 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*/);
-
+ 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);
: declare_variables),
(options.gen.semantic_icache
? both_values_and_icache
- : put_values_in_icache),
- nr_prefetched_words);
-
+ : 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);
+ 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, "/* 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");
instruction->name,
instruction->format_name,
NULL,
- expanded_bits,
- function_name_prefix_semantics);
+ expanded_bits, function_name_prefix_semantics);
lf_printf (file, ";\n");
}
-
+
if (options.gen.direct_access)
{
print_icache_body (file,
undef_variables,
(options.gen.semantic_icache
? both_values_and_icache
- : put_values_in_icache),
- nr_prefetched_words);
+ : put_values_in_icache), nr_prefetched_words);
}
-
+
lf_indent (file, -2);
lf_printf (file, "}\n");
lf_indent (file, -2);
void
print_icache_definition (lf *file,
- insn_entry *insn,
+ insn_entry * insn,
opcode_bits *expanded_bits,
insn_opcodes *opcodes,
- cache_entry *cache_rules,
- int nr_prefetched_words)
+ cache_entry *cache_rules, int nr_prefetched_words)
{
print_icache_function (file,
insn,
expanded_bits,
- opcodes,
- cache_rules,
- nr_prefetched_words);
+ opcodes, cache_rules, nr_prefetched_words);
}
void
print_icache_internal_function_declaration (lf *file,
- function_entry *function,
+ function_entry * function,
void *data)
{
ASSERT (options.gen.icache);
"INLINE_ICACHE", "\n");
print_function_name (file,
function->name,
- NULL,
- NULL,
- NULL,
- function_name_prefix_icache);
+ 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,
+ function_entry * function,
void *data)
{
ASSERT (options.gen.icache);
"INLINE_ICACHE", "\n");
print_function_name (file,
function->name,
- NULL,
- NULL,
- NULL,
- function_name_prefix_icache);
+ NULL, NULL, NULL, function_name_prefix_icache);
lf_printf (file, "\n(");
print_icache_function_formal (file, 0);
lf_printf (file, ")\n");
{
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,
+ "error (\"Internal function must longjump\\n\");\n");
lf_printf (file, "return 0;\n");
}
else
print_function_name (file,
function->name,
NULL,
- NULL,
- NULL,
- function_name_prefix_semantics);
+ NULL, NULL, function_name_prefix_semantics);
lf_printf (file, ";\n");
}
-
+
lf_print__internal_ref (file);
lf_indent (file, -2);
lf_printf (file, "}\n");
/* Output code to manipulate the instruction cache: either create it
or reference it */
-typedef enum {
+typedef enum
+{
declare_variables,
define_variables,
undef_variables,
-} icache_decl_type;
+}
+icache_decl_type;
-typedef enum {
+typedef enum
+{
do_not_use_icache = 0,
get_values_from_icache = 0x1,
put_values_in_icache = 0x2,
both_values_and_icache = 0x3,
-} icache_body_type;
+}
+icache_body_type;
extern 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);
+ (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);
/* Output an instruction cache decode function */
extern void print_icache_declaration
-(lf *file,
- insn_entry *insn,
- opcode_bits *expanded_bits,
- insn_opcodes *opcodes,
- int nr_prefetched_words);
-
+ (lf *file,
+ insn_entry * insn,
+ opcode_bits *expanded_bits,
+ insn_opcodes *opcodes, int nr_prefetched_words);
+
extern void print_icache_definition
-(lf *file,
- insn_entry *insn,
- opcode_bits *expanded_bits,
- insn_opcodes *opcodes,
- cache_entry *cache_rules,
- int nr_prefetched_words);
+ (lf *file,
+ insn_entry * insn,
+ opcode_bits *expanded_bits,
+ insn_opcodes *opcodes, cache_entry *cache_rules, int nr_prefetched_words);
/* Output an instruction cache support function */
/* Output the instruction cache table data structure */
extern void print_icache_struct
-(lf *file,
- insn_table *instructions,
- cache_entry *cache_rules);
+ (lf *file, insn_table *instructions, cache_entry *cache_rules);
/* Output a single instructions decoder */
static void
-lf_print_opcodes (lf *file,
- gen_entry *table)
+lf_print_opcodes (lf *file, gen_entry *table)
{
- if (table != NULL)
+ if (table !=NULL)
{
while (1)
{
ASSERT (table->opcode != NULL);
lf_printf (file, "_%d_%d",
- table->opcode->first,
- table->opcode->last);
- if (table->parent == NULL) break;
+ table->opcode->first, table->opcode->last);
+ if (table->parent == NULL)
+ break;
lf_printf (file, "__%d", table->opcode_nr);
table = table->parent;
}
{
int word_nr;
for (word_nr = previous_nr_prefetched_words;
- word_nr < current_nr_prefetched_words;
- word_nr ++)
+ word_nr < current_nr_prefetched_words; word_nr++)
{
- lf_printf (file, "instruction_word instruction_%d = IMEM%d_IMMED (cia, %d);\n",
+ lf_printf (file,
+ "instruction_word instruction_%d = IMEM%d_IMMED (cia, %d);\n",
word_nr, options.insn_bit_size, word_nr);
-
+
}
}
static void
-lf_print_table_name (lf *file,
- gen_entry *table)
+lf_print_table_name (lf *file, gen_entry *table)
{
lf_printf (file, "idecode_table");
lf_print_opcodes (file, table);
static void
-print_idecode_table (lf *file,
- gen_entry *entry,
- const char *result)
+print_idecode_table (lf *file, gen_entry *entry, const char *result)
{
lf_printf (file, "/* prime the search */\n");
lf_printf (file, "idecode_table_entry *table = ");
i2target (options.hi_bit_nr, entry->opcode->first),
i2target (options.hi_bit_nr, entry->opcode->last));
lf_printf (file, "idecode_table_entry *table_entry = table + opcode;\n");
-
+
lf_printf (file, "\n");
lf_printf (file, "/* iterate until a leaf */\n");
lf_printf (file, "while (1) {\n");
lf_printf (file, " table_entry = table + opcode;\n");
lf_printf (file, " }\n");
lf_printf (file, "}\n");
-
+
lf_printf (file, "\n");
lf_printf (file, "/* call the leaf code */\n");
if (options.gen.code == generate_jumps)
lf_printf (file, "%s ", result);
if (options.gen.icache)
{
- lf_printf (file, "(((idecode_icache*)table_entry->function_or_table)\n");
+ lf_printf (file,
+ "(((idecode_icache*)table_entry->function_or_table)\n");
lf_printf (file, " (");
print_icache_function_actual (file, 1);
lf_printf (file, "));\n");
}
else
{
- lf_printf (file, "((idecode_semantic*)table_entry->function_or_table)\n");
+ lf_printf (file,
+ "((idecode_semantic*)table_entry->function_or_table)\n");
lf_printf (file, " (");
print_semantic_function_actual (file, 1);
lf_printf (file, ");\n");
static void
-print_idecode_table_start (lf *file,
- gen_entry *table,
- int depth,
- void *data)
+print_idecode_table_start (lf *file, gen_entry *table, int depth, void *data)
{
ASSERT (depth == 0);
/* start of the table */
}
static void
-print_idecode_table_leaf (lf *file,
- gen_entry *entry,
- int depth,
- void *data)
+print_idecode_table_leaf (lf *file, gen_entry *entry, int depth, void *data)
{
gen_entry *master_entry;
ASSERT (entry->parent != NULL);
else
{
/* table `calling' another table */
- lf_printf (file, "%d, ", options.insn_bit_size - entry->opcode->last - 1);
- lf_printf (file, "MASK%d(%d,%d), ",
- options.insn_bit_size,
+ lf_printf (file, "%d, ",
+ options.insn_bit_size - entry->opcode->last - 1);
+ lf_printf (file, "MASK%d(%d,%d), ", options.insn_bit_size,
i2target (options.hi_bit_nr, entry->opcode->first),
i2target (options.hi_bit_nr, entry->opcode->last));
lf_printf (file, "0, ");
}
static void
-print_idecode_table_end (lf *file,
- gen_entry *table,
- int depth,
- void *data)
+print_idecode_table_end (lf *file, gen_entry *table, int depth, void *data)
{
ASSERT (depth == 0);
- if (table->opcode_rule->gen == array_gen) {
- lf_printf (file, "};\n");
- }
+ if (table->opcode_rule->gen == array_gen)
+ {
+ lf_printf (file, "};\n");
+ }
}
/****************************************************************/
static void
-print_goto_switch_name (lf *file,
- gen_entry *entry)
+print_goto_switch_name (lf *file, gen_entry *entry)
{
lf_printf (file, "case_");
if (entry->opcode == NULL)
}
else
{
- lf_print_table_name(file, entry);
+ lf_print_table_name (file, entry);
}
}
static void
print_goto_switch_table_leaf (lf *file,
- gen_entry *entry,
- int depth,
- void *data)
+ gen_entry *entry, int depth, void *data)
{
ASSERT (entry->parent != NULL);
ASSERT (depth == 0);
ASSERT (entry->parent->opcode_rule->gen == goto_switch_gen);
ASSERT (entry->parent->opcode);
-
+
lf_printf (file, "/* %d */ &&", entry->opcode_nr);
if (entry->combined_parent != NULL)
print_goto_switch_name (file, entry->combined_parent);
}
static void
-print_goto_switch_break (lf *file,
- gen_entry *entry)
+print_goto_switch_break (lf *file, gen_entry *entry)
{
lf_printf (file, "goto break_");
lf_print_table_name (file, entry->parent);
static void
-print_goto_switch_table (lf *file,
- gen_entry *table)
+print_goto_switch_table (lf *file, gen_entry *table)
{
lf_printf (file, "const static void *");
lf_print_table_name (file, table);
lf_printf (file, "[] = {\n");
lf_indent (file, +2);
- gen_entry_traverse_tree (file, table,
- 0,
- NULL/*start*/,
- print_goto_switch_table_leaf,
- NULL/*end*/,
- NULL/*data*/);
+ gen_entry_traverse_tree (file, table, 0, NULL /*start */ ,
+ print_goto_switch_table_leaf, NULL /*end */ ,
+ NULL /*data */ );
lf_indent (file, -2);
lf_printf (file, "};\n");
}
-void print_idecode_switch
-(lf *file,
- gen_entry *table,
- const char *result);
+void print_idecode_switch (lf *file, gen_entry *table, const char *result);
static void
-print_idecode_switch_start (lf *file,
- gen_entry *table,
- int depth,
- void *data)
+print_idecode_switch_start (lf *file, gen_entry *table, int depth, void *data)
{
/* const char *result = data; */
ASSERT (depth == 0);
ASSERT (table->opcode_rule->gen == switch_gen
|| table->opcode_rule->gen == goto_switch_gen
|| table->opcode_rule->gen == padded_switch_gen);
-
+
if (table->opcode->is_boolean
|| table->opcode_rule->gen == switch_gen
|| table->opcode_rule->gen == padded_switch_gen)
}
else
{
- ASSERT("bad switch" == NULL);
+ ASSERT ("bad switch" == NULL);
}
}
static void
-print_idecode_switch_leaf (lf *file,
- gen_entry *entry,
- int depth,
- void *data)
+print_idecode_switch_leaf (lf *file, gen_entry *entry, int depth, void *data)
{
const char *result = data;
ASSERT (entry->parent != NULL);
|| entry->parent->opcode_rule->gen == goto_switch_gen
|| entry->parent->opcode_rule->gen == padded_switch_gen);
ASSERT (entry->parent->opcode);
-
+
/* skip over any instructions combined into another entry */
if (entry->combined_parent != NULL)
return;
- if (entry->parent->opcode->is_boolean
- && entry->opcode_nr == 0)
+ if (entry->parent->opcode->is_boolean && entry->opcode_nr == 0)
{
/* case: boolean false target */
lf_printf (file, "case %d:\n", entry->parent->opcode->boolean_constant);
}
- else if (entry->parent->opcode->is_boolean
- && entry->opcode_nr != 0)
+ else if (entry->parent->opcode->is_boolean && entry->opcode_nr != 0)
{
/* case: boolean true case */
lf_printf (file, "default:\n");
if (options.gen.code == generate_calls)
{
lf_printf (file, " (");
- print_semantic_function_actual (file, entry->insns->semantic->nr_prefetched_words);
+ print_semantic_function_actual (file,
+ entry->insns->semantic->
+ nr_prefetched_words);
lf_printf (file, ")");
}
lf_printf (file, ";\n");
}
else if (entry->parent->opcode_rule->gen == goto_switch_gen)
{
- print_goto_switch_break(file, entry);
+ print_goto_switch_break (file, entry);
}
else
{
static void
-print_idecode_switch_illegal (lf *file,
- const char *result)
+print_idecode_switch_illegal (lf *file, const char *result)
{
lf_indent (file, +2);
print_idecode_invalid (file, result, invalid_illegal);
}
static void
-print_idecode_switch_end (lf *file,
- gen_entry *table,
- int depth,
- void *data)
+print_idecode_switch_end (lf *file, gen_entry *table, int depth, void *data)
{
const char *result = data;
ASSERT (depth == 0);
|| table->opcode_rule->gen == goto_switch_gen
|| table->opcode_rule->gen == padded_switch_gen);
ASSERT (table->opcode);
-
+
if (table->opcode->is_boolean)
{
lf_printf (file, "}\n");
lf_indent (file, +2);
if (table->nr_entries == table->opcode->nr_opcodes)
{
- print_sim_engine_abort (file, "Internal error - bad switch generated");
+ print_sim_engine_abort (file,
+ "Internal error - bad switch generated");
lf_printf (file, "%sNULL_CIA;\n", result);
lf_printf (file, "break;\n");
}
lf_printf (file, ":\n");
print_idecode_invalid (file, result, invalid_illegal);
lf_printf (file, "break_");
- lf_print_table_name(file, table);
+ lf_print_table_name (file, table);
lf_printf (file, ":;\n");
if (table->parent != NULL
&& (table->parent->opcode_rule->gen == switch_gen
void
-print_idecode_switch (lf *file,
- gen_entry *table,
- const char *result)
+print_idecode_switch (lf *file, gen_entry *table, const char *result)
{
gen_entry_traverse_tree (file, table,
0,
print_idecode_switch_start,
print_idecode_switch_leaf,
- print_idecode_switch_end,
- (void*)result);
+ print_idecode_switch_end, (void *) result);
}
static void
-idecode_declare_if_switch (lf *file,
- gen_entry *table,
- int depth,
- void *data)
+idecode_declare_if_switch (lf *file, gen_entry *table, int depth, void *data)
{
- if ((table->opcode_rule->gen == switch_gen
- || table->opcode_rule->gen == goto_switch_gen
- || table->opcode_rule->gen == padded_switch_gen)
- && table->parent != NULL /* don't declare the top one yet */
+ if ((table->opcode_rule->gen == switch_gen || table->opcode_rule->gen == goto_switch_gen || table->opcode_rule->gen == padded_switch_gen) &&table->parent != NULL /* don't declare the top one yet */
&& table->parent->opcode_rule->gen == array_gen)
{
print_idecode_switch_function_header (file,
table,
- 0/*isnt function definition*/,
+ 0 /*isnt function definition */ ,
0);
}
}
static void
-idecode_expand_if_switch (lf *file,
- gen_entry *table,
- int depth,
- void *data)
+idecode_expand_if_switch (lf *file, gen_entry *table, int depth, void *data)
{
- if ((table->opcode_rule->gen == switch_gen
- || table->opcode_rule->gen == goto_switch_gen
- || table->opcode_rule->gen == padded_switch_gen)
- && table->parent != NULL /* don't expand the top one yet */
+ if ((table->opcode_rule->gen == switch_gen || table->opcode_rule->gen == goto_switch_gen || table->opcode_rule->gen == padded_switch_gen) &&table->parent != NULL /* don't expand the top one yet */
&& table->parent->opcode_rule->gen == array_gen)
{
- print_idecode_switch_function_header(file,
- table,
- 1/*is function definition*/,
- 0);
+ print_idecode_switch_function_header (file,
+ table,
+ 1 /*is function definition */ ,
+ 0);
if (options.gen.code == generate_calls)
{
lf_printf (file, "{\n");
lf_indent (file, +2);
}
- print_idecode_switch(file, table, "return");
+ print_idecode_switch (file, table, "return");
if (options.gen.code == generate_calls)
{
lf_indent (file, -2);
void
-print_idecode_lookups (lf *file,
- gen_entry *table,
- cache_entry *cache_rules)
+print_idecode_lookups (lf *file, gen_entry *table, cache_entry *cache_rules)
{
int depth;
-
+
/* output switch function declarations where needed by tables */
- gen_entry_traverse_tree (file, table,
- 1,
- idecode_declare_if_switch, /* START */
- NULL, NULL,
- NULL);
-
+ gen_entry_traverse_tree (file, table, 1, idecode_declare_if_switch, /* START */
+ NULL, NULL, NULL);
+
/* output tables where needed */
- for (depth = gen_entry_depth (table);
- depth > 0;
- depth--)
+ for (depth = gen_entry_depth (table); depth > 0; depth--)
{
gen_entry_traverse_tree (file, table,
- 1-depth,
+ 1 - depth,
print_idecode_table_start,
print_idecode_table_leaf,
- print_idecode_table_end,
- NULL);
+ print_idecode_table_end, NULL);
}
-
+
/* output switch functions where needed */
- gen_entry_traverse_tree (file, table,
- 1,
- idecode_expand_if_switch, /* START */
- NULL, NULL,
- NULL);
+ gen_entry_traverse_tree (file, table, 1, idecode_expand_if_switch, /* START */
+ NULL, NULL, NULL);
}
void
-print_idecode_body (lf *file,
- gen_entry *table,
- const char *result)
+print_idecode_body (lf *file, gen_entry *table, const char *result)
{
if (table->opcode_rule->gen == switch_gen
|| table->opcode_rule->gen == goto_switch_gen
#if 0
static void
-print_jump (lf *file,
- int is_tail)
+print_jump (lf *file, int is_tail)
{
if (is_tail)
{
lf_putstr (file, "if (keep_running != NULL && !*keep_running)\n");
lf_putstr (file, " cpu_halt(cpu, nia, was_continuing, 0/*na*/);\n");
}
-
+
if (!options.generate_smp)
{
lf_putstr (file, "if (WITH_EVENTS) {\n");
lf_putstr (file, " }\n");
lf_putstr (file, "}\n");
}
-
+
if (options.generate_smp)
{
if (is_tail)
lf_putstr (file, "cpu = cpus[current_cpu];\n");
lf_putstr (file, "nia = cpu_get_program_counter(cpu);\n");
}
-
+
if (options.gen.icache)
{
lf_putstr (file, "cache_entry = cpu_icache_entry(cpu, nia);\n");
{
lf_printf (file, "goto idecode;\n");
}
-
+
}
#endif
#if 0
static void
print_jump_insn (lf *file,
- insn_entry *instruction,
- insn_bits *expanded_bits,
- opcode_field *opcodes,
- cache_entry *cache_rules)
+ insn_entry * instruction,
+ insn_bits * expanded_bits,
+ opcode_field *opcodes, cache_entry *cache_rules)
{
-
+
/* what we are for the moment */
lf_printf (file, "\n");
print_my_defines (file, expanded_bits, instruction->name);
-
+
/* output the icache entry */
if (options.gen.icache)
{
lf_indent (file, -1);
print_function_name (file,
instruction->name,
- expanded_bits,
- function_name_prefix_icache);
+ expanded_bits, function_name_prefix_icache);
lf_printf (file, ":\n");
lf_indent (file, +1);
lf_printf (file, "{\n");
lf_indent (file, +2);
lf_putstr (file, "const unsigned_word cia = nia;\n");
- print_itrace (file, instruction, 1/*putting-value-in-cache*/);
+ 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);
- print_icache_body (file,
- instruction,
- expanded_bits,
- cache_rules,
- 0, /*use_defines*/
+ print_icache_body (file, instruction, expanded_bits, cache_rules, 0, /*use_defines */
put_values_in_icache);
lf_printf (file, "cache_entry->address = nia;\n");
lf_printf (file, "cache_entry->semantic = &&");
print_function_name (file,
instruction->name,
- expanded_bits,
- function_name_prefix_semantics);
+ expanded_bits, function_name_prefix_semantics);
lf_printf (file, ";\n");
if (options.gen.semantic_icache)
{
- print_semantic_body (file,
- instruction,
- expanded_bits,
- opcodes);
- print_jump (file, 1/*is-tail*/);
+ print_semantic_body (file, instruction, expanded_bits, opcodes);
+ print_jump (file, 1 /*is-tail */ );
}
else
{
lf_printf (file, "/* goto ");
print_function_name (file,
instruction->name,
- expanded_bits,
- function_name_prefix_semantics);
+ expanded_bits, function_name_prefix_semantics);
lf_printf (file, "; */\n");
}
lf_indent (file, -2);
lf_indent (file, -2);
lf_printf (file, "}\n");
}
-
+
/* print the semantics */
lf_printf (file, "\n");
lf_indent (file, -1);
print_function_name (file,
instruction->name,
- expanded_bits,
- function_name_prefix_semantics);
+ expanded_bits, function_name_prefix_semantics);
lf_printf (file, ":\n");
lf_indent (file, +1);
lf_printf (file, "{\n");
? define_variables
: declare_variables),
(options.gen.icache
- ? get_values_from_icache
- : do_not_use_icache));
- print_semantic_body (file,
- instruction,
- expanded_bits,
- opcodes);
+ ? get_values_from_icache : do_not_use_icache));
+ print_semantic_body (file, instruction, expanded_bits, opcodes);
if (options.gen.direct_access)
print_icache_body (file,
instruction,
cache_rules,
undef_variables,
(options.gen.icache
- ? get_values_from_icache
- : do_not_use_icache));
- print_jump (file, 1/*is tail*/);
+ ? get_values_from_icache : do_not_use_icache));
+ print_jump (file, 1 /*is tail */ );
lf_indent (file, -2);
lf_printf (file, "}\n");
}
static void
print_jump_definition (lf *file,
gen_entry *entry,
- insn_entry *insn,
- int depth,
- void *data)
+ insn_entry * insn, int depth, void *data)
{
- cache_entry *cache_rules = (cache_entry*)data;
+ cache_entry *cache_rules = (cache_entry *) data;
if (options.generate_expanded_instructions)
{
ASSERT (entry->nr_insns == 1
&& entry->opcode == NULL
- && entry->parent != NULL
- && entry->parent->opcode != NULL);
+ && entry->parent != NULL && entry->parent->opcode != NULL);
ASSERT (entry->nr_insns == 1
&& entry->opcode == NULL
&& entry->parent != NULL
&& entry->parent->opcode_rule != NULL);
print_jump_insn (file,
entry->insns->words[0]->insn,
- entry->expanded_bits,
- entry->opcode,
- cache_rules);
+ entry->expanded_bits, entry->opcode, cache_rules);
}
else
{
print_jump_insn (file,
- instruction->words[0]->insn,
- NULL,
- NULL,
- cache_rules);
+ instruction->words[0]->insn, NULL, NULL, cache_rules);
}
}
#endif
static void
print_jump_internal_function (lf *file,
gen_entry *table,
- function_entry *function,
- void *data)
+ function_entry * function, void *data)
{
if (function->is_internal)
{
#if 0
static void
-print_jump_until_stop_body(lf *file,
- insn_table *table,
- cache_table *cache_rules)
+print_jump_until_stop_body (lf *file,
+ insn_table *table, cache_table * cache_rules)
{
lf_printf (file, "{\n");
lf_indent (file, +2);
lf_putstr (file, "sim_cpu *cpu = NULL;\n");
lf_putstr (file, "unsigned_word nia = -1;\n");
lf_putstr (file, "instruction_word instruction = 0;\n");
- if ((code & generate_with_icache)) {
- lf_putstr (file, "idecode_cache *cache_entry = NULL;\n");
- }
- if (generate_smp) {
- lf_putstr (file, "int current_cpu = -1;\n");
- }
+ if ((code & generate_with_icache))
+ {
+ lf_putstr (file, "idecode_cache *cache_entry = NULL;\n");
+ }
+ if (generate_smp)
+ {
+ lf_putstr (file, "int current_cpu = -1;\n");
+ }
/* all the switches and tables - they know about jumping */
- print_idecode_lookups(file, table, cache_rules);
-
+ print_idecode_lookups (file, table, cache_rules);
+
/* start the simulation up */
- if ((code & generate_with_icache)) {
- lf_putstr (file, "\n");
- lf_putstr (file, "{\n");
- lf_putstr (file, " int cpu_nr;\n");
- lf_putstr (file, " for (cpu_nr = 0; cpu_nr < nr_cpus; cpu_nr++)\n");
- lf_putstr (file, " cpu_flush_icache(cpus[cpu_nr]);\n");
- lf_putstr (file, "}\n");
- }
+ if ((code & generate_with_icache))
+ {
+ lf_putstr (file, "\n");
+ lf_putstr (file, "{\n");
+ lf_putstr (file, " int cpu_nr;\n");
+ lf_putstr (file, " for (cpu_nr = 0; cpu_nr < nr_cpus; cpu_nr++)\n");
+ lf_putstr (file, " cpu_flush_icache(cpus[cpu_nr]);\n");
+ lf_putstr (file, "}\n");
+ }
lf_putstr (file, "\n");
lf_putstr (file, "psim_set_halt_and_restart(system, &halt, &restart);\n");
lf_putstr (file, "setjmp(restart);\n");
lf_putstr (file, "\n");
- if (!generate_smp) {
- lf_putstr (file, "cpu = cpus[0];\n");
- lf_putstr (file, "nia = cpu_get_program_counter(cpu);\n");
- }
- else {
- lf_putstr (file, "current_cpu = psim_last_cpu(system);\n");
- }
+ if (!generate_smp)
+ {
+ lf_putstr (file, "cpu = cpus[0];\n");
+ lf_putstr (file, "nia = cpu_get_program_counter(cpu);\n");
+ }
+ else
+ {
+ lf_putstr (file, "current_cpu = psim_last_cpu(system);\n");
+ }
- if (!(code & generate_with_icache)) {
- lf_printf (file, "\n");
- lf_indent (file, -1);
- lf_printf (file, "idecode:\n");
- lf_indent (file, +1);
- }
+ if (!(code & generate_with_icache))
+ {
+ lf_printf (file, "\n");
+ lf_indent (file, -1);
+ lf_printf (file, "idecode:\n");
+ lf_indent (file, +1);
+ }
- print_jump(file, 0/*is_tail*/);
+ print_jump (file, 0 /*is_tail */ );
- if ((code & generate_with_icache)) {
- lf_indent (file, -1);
- lf_printf (file, "cache_miss:\n");
- lf_indent (file, +1);
- }
+ if ((code & generate_with_icache))
+ {
+ lf_indent (file, -1);
+ lf_printf (file, "cache_miss:\n");
+ lf_indent (file, +1);
+ }
lf_putstr (file, "instruction\n");
lf_putstr (file, " = vm_instruction_map_read(cpu_instruction_map(cpu),\n");
lf_putstr (file, " cpu, nia);\n");
- print_idecode_body(file, table, "/*IGORE*/");
+ print_idecode_body (file, table, "/*IGORE*/");
/* print out a table of all the internals functions */
- insn_table_traverse_function(table,
- file, NULL,
- print_jump_internal_function);
+ insn_table_traverse_function (table,
+ file, NULL, print_jump_internal_function);
- /* print out a table of all the instructions */
+ /* print out a table of all the instructions */
if (generate_expanded_instructions)
- insn_table_traverse_tree(table,
- file, cache_rules,
- 1,
- NULL, /* start */
- print_jump_definition, /* leaf */
- NULL, /* end */
- NULL); /* padding */
+ insn_table_traverse_tree (table, file, cache_rules, 1, NULL, /* start */
+ print_jump_definition, /* leaf */
+ NULL, /* end */
+ NULL); /* padding */
else
- insn_table_traverse_insn(table,
- file, cache_rules,
- print_jump_definition);
+ insn_table_traverse_insn (table,
+ file, cache_rules, print_jump_definition);
lf_indent (file, -2);
lf_printf (file, "}\n");
}
void
print_idecode_validate (lf *file,
- insn_entry *instruction,
- insn_opcodes *opcode_paths)
+ insn_entry * instruction, insn_opcodes *opcode_paths)
{
/* Validate: unchecked instruction fields
/* Make space for the next bit */
check_mask <<= 1;
check_val <<= 1;
-
+
/* Only need to validate constant (and reserved)
- bits. Skip any others */
+ bits. Skip any others */
if (field->type != insn_field_int
&& field->type != insn_field_reserved)
continue;
/* Look through the list of opcode paths that lead to this
- instruction. See if any have failed to check the
- relevant bit */
+ instruction. See if any have failed to check the
+ relevant bit */
if (opcode_paths != NULL)
{
insn_opcodes *entry;
- for (entry = opcode_paths;
- entry != NULL;
- entry = entry->next)
+ for (entry = opcode_paths; entry != NULL; entry = entry->next)
{
opcode_field *opcode;
for (opcode = entry->opcode;
- opcode != NULL;
- opcode = opcode->parent)
+ opcode != NULL; opcode = opcode->parent)
{
if (opcode->word_nr == word_nr
&& opcode->first <= bit_nr
}
if (entry == NULL)
/* all the opcode paths decoded on BIT_NR, no need
- to check it */
+ to check it */
continue;
}
-
+
check_mask |= 1;
check_val |= bit->value;
}
-
+
/* if any bits not checked by opcode tables, output code to check them */
if (check_mask)
{
lf_printf (file, " {\n");
lf_indent (file, +4);
}
- nr_checks ++;
+ nr_checks++;
if (options.insn_bit_size > 32)
{
- lf_printf (file, "if ((instruction_%d\n", word_nr);
+ lf_printf (file, "if ((instruction_%d\n", word_nr);
lf_printf (file, " & UNSIGNED64 (0x%08lx%08lx))\n",
- (unsigned long)(check_mask >> 32),
- (unsigned long)(check_mask));
+ (unsigned long) (check_mask >> 32),
+ (unsigned long) (check_mask));
lf_printf (file, " != UNSIGNED64 (0x%08lx%08lx))\n",
- (unsigned long)(check_val >> 32),
- (unsigned long)(check_val));
+ (unsigned long) (check_val >> 32),
+ (unsigned long) (check_val));
}
else
{
- lf_printf (file, "if ((instruction_%d & 0x%08lx) != 0x%08lx)\n",
- word_nr,
- (unsigned long)(check_mask),
- (unsigned long)(check_val));
+ lf_printf (file,
+ "if ((instruction_%d & 0x%08lx) != 0x%08lx)\n",
+ word_nr, (unsigned long) (check_mask),
+ (unsigned long) (check_val));
}
lf_indent (file, +2);
print_idecode_invalid (file, "return", invalid_illegal);
lf_indent (file, -4);
lf_printf (file, " }\n");
}
- lf_indent_suppress(file);
+ lf_indent_suppress (file);
lf_printf (file, "#endif\n");
}
/* Validate: Floating Point hardware
-
+
If the simulator is being built with out floating point hardware
(different to it being disabled in the MSR) then floating point
instructions are invalid */
lf_indent_suppress (file);
lf_printf (file, "#if defined(CURRENT_FLOATING_POINT)\n");
lf_printf (file, "/* Validate: FP hardware exists */\n");
- lf_printf (file, "if (CURRENT_FLOATING_POINT != HARD_FLOATING_POINT) {\n");
+ lf_printf (file,
+ "if (CURRENT_FLOATING_POINT != HARD_FLOATING_POINT) {\n");
lf_indent (file, +2);
print_idecode_invalid (file, "return", invalid_illegal);
lf_indent (file, -2);
lf_printf (file, "/* Validate: FP available according to cpu */\n");
lf_printf (file, "if (!IS_FP_AVAILABLE) {\n");
lf_indent (file, +2);
- print_idecode_invalid (file, "return", invalid_fp_unavailable);
+ print_idecode_invalid (file, "return", invalid_fp_unavailable);
lf_indent (file, -2);
lf_printf (file, "}\n");
lf_indent_suppress (file);
lf_printf (file, "#endif\n");
}
}
-
+
/* Validate: Validate Instruction in correct slot
Some architectures place restrictions on the slot that an
lf_printf (file, "\n");
lf_indent_suppress (file);
lf_printf (file, "#if defined(IS_WRONG_SLOT)\n");
- lf_printf (file, "/* Validate: Instruction issued in correct slot */\n");
+ lf_printf (file,
+ "/* Validate: Instruction issued in correct slot */\n");
lf_printf (file, "if (IS_WRONG_SLOT) {\n");
lf_indent (file, +2);
print_idecode_invalid (file, "return", invalid_wrong_slot);
lf_printf (file, "#endif\n");
}
}
-
+
}
{
case is_function_declaration:
lf_print__function_type_function (file, print_semantic_function_type,
- "INLINE_IDECODE",
- " ");
+ "INLINE_IDECODE", " ");
break;
case is_function_definition:
lf_print__function_type_function (file, print_semantic_function_type,
- "INLINE_IDECODE",
- "\n");
+ "INLINE_IDECODE", "\n");
break;
case is_function_variable:
print_semantic_function_type (file);
"issue",
NULL,
processor,
- NULL,
- function_name_prefix_idecode);
+ NULL, function_name_prefix_idecode);
switch (decl_type)
{
case is_function_definition:
void print_idecode_issue_function_header
-(lf *file,
- const char *processor,
- function_decl_type decl_type,
- int nr_prefetched_words);
+ (lf *file,
+ const char *processor,
+ function_decl_type decl_type, int nr_prefetched_words);
-void print_idecode_globals
-(lf *file);
+void print_idecode_globals (lf *file);
void print_idecode_lookups
-(lf *file,
- gen_entry *table,
- cache_entry *cache_rules);
+ (lf *file, gen_entry *table, cache_entry *cache_rules);
-void print_idecode_body
-(lf *file,
- gen_entry *table,
- const char *result);
+void print_idecode_body (lf *file, gen_entry *table, const char *result);
hardware isn't disabled */
extern void print_idecode_validate
-(lf *file,
- insn_entry *instruction,
- insn_opcodes *opcode_paths);
+ (lf *file, insn_entry * instruction, insn_opcodes *opcode_paths);
-typedef struct _itable_info {
+typedef struct _itable_info
+{
int sizeof_form;
int sizeof_name;
int sizeof_file;
-} itable_info;
+}
+itable_info;
static void
itable_h_insn (lf *file,
- insn_table *entry,
- insn_entry *instruction,
- void *data)
+ insn_table *entry, insn_entry * instruction, void *data)
{
int len;
itable_info *info = data;
print_function_name (file,
instruction->name,
instruction->format_name,
- NULL,
- NULL,
- function_name_prefix_itable);
+ NULL, NULL, function_name_prefix_itable);
lf_printf (file, ",\n");
/* update summary info */
len = strlen (instruction->format_name);
/* print the list of all the different options */
static void
-itable_print_enum (lf *file,
- filter *set,
- char *name)
+itable_print_enum (lf *file, filter *set, char *name)
{
char *elem;
lf_printf (file, "typedef enum {\n");
lf_indent (file, +2);
for (elem = filter_next (set, "");
- elem != NULL;
- elem = filter_next (set, elem))
+ elem != NULL; elem = filter_next (set, elem))
{
lf_printf (file, "%sitable_%s_%s,\n",
options.module.itable.prefix.l, name, elem);
name, elem, options.module.itable.prefix.l, name, elem);
}
}
- lf_printf (file, "nr_%sitable_%ss,\n", options.module.itable.prefix.l, name);
-
+ lf_printf (file, "nr_%sitable_%ss,\n", options.module.itable.prefix.l,
+ name);
+
lf_indent (file, -2);
lf_printf (file, "} %sitable_%ss;\n", options.module.itable.prefix.l, name);
if (strlen (options.module.itable.prefix.l) > 0)
/* print an array of the option names as strings */
static void
-itable_print_names (lf *file,
- filter *set,
- char *name)
+itable_print_names (lf *file, filter *set, char *name)
{
char *elem;
lf_printf (file, "const char *%sitable_%s_names[nr_%sitable_%ss + 1] = {\n",
options.module.itable.prefix.l, name);
lf_indent (file, +2);
for (elem = filter_next (set, "");
- elem != NULL;
- elem = filter_next (set, elem))
+ elem != NULL; elem = filter_next (set, elem))
{
lf_printf (file, "\"%s\",\n", elem);
}
lf_printf (file, "};\n");
}
-extern void
-gen_itable_h (lf *file,
- insn_table *isa)
+extern void
+gen_itable_h (lf *file, insn_table *isa)
{
itable_info *info = ZALLOC (itable_info);
/* output an enumerated type for each instruction */
lf_printf (file, "typedef enum {\n");
insn_table_traverse_insn (file, isa, itable_h_insn, info);
- lf_printf (file, " nr_%sitable_entries,\n", options.module.itable.prefix.l);
+ lf_printf (file, " nr_%sitable_entries,\n",
+ options.module.itable.prefix.l);
lf_printf (file, "} %sitable_index;\n", options.module.itable.prefix.l);
lf_printf (file, "\n");
lf_printf (file, "extern const char *%sitable_flag_names[];\n",
options.module.itable.prefix.l);
lf_printf (file, "\n");
-
+
/* output an enumeration of all the possible options */
itable_print_enum (file, isa->options, "option");
lf_printf (file, "extern const char *%sitable_option_names[];\n",
/****************************************************************/
static void
-itable_print_set (lf *file,
- filter *set,
- filter *members)
+itable_print_set (lf *file, filter *set, filter *members)
{
char *elem;
lf_printf (file, "\"");
}
lf_printf (file, "\",\n");
- lf_printf(file, "{");
+ lf_printf (file, "{");
for (elem = filter_next (set, "");
- elem != NULL;
- elem = filter_next (set, elem))
+ elem != NULL; elem = filter_next (set, elem))
{
if (filter_is_member (members, elem))
{
{
lf_printf (file, " 0,");
}
-
+
}
/* always print a dummy element, to avoid empty initializers. */
- lf_printf(file, " 99 },\n");
+ lf_printf (file, " 99 },\n");
}
static void
itable_c_insn (lf *file,
- insn_table *isa,
- insn_entry *instruction,
- void *data)
+ insn_table *isa, insn_entry * instruction, void *data)
{
lf_printf (file, "{ ");
lf_indent (file, +2);
print_function_name (file,
instruction->name,
instruction->format_name,
- NULL,
- NULL,
- function_name_prefix_itable);
+ NULL, NULL, function_name_prefix_itable);
lf_printf (file, ",\n");
lf_printf (file, "\"");
print_insn_words (file, instruction);
itable_print_set (file, isa->options, instruction->options);
itable_print_set (file, isa->model->processors, instruction->processors);
- lf_printf(file, "\"%s\",\n", instruction->name);
- lf_printf(file, "\"%s\",\n",
- filter_filename (instruction->line->file_name));
- lf_printf(file, "%d,\n", instruction->line->line_nr);
- lf_printf(file, "},\n");
+ lf_printf (file, "\"%s\",\n", instruction->name);
+ lf_printf (file, "\"%s\",\n",
+ filter_filename (instruction->line->file_name));
+ lf_printf (file, "%d,\n", instruction->line->line_nr);
+ lf_printf (file, "},\n");
lf_indent (file, -2);
}
-extern void
-gen_itable_c (lf *file,
- insn_table *isa)
+extern void
+gen_itable_c (lf *file, insn_table *isa)
{
/* leader */
- lf_printf(file, "#include \"%sitable.h\"\n", options.module.itable.prefix.l);
- lf_printf(file, "\n");
+ lf_printf (file, "#include \"%sitable.h\"\n",
+ options.module.itable.prefix.l);
+ lf_printf (file, "\n");
/* FIXME - output model data??? */
/* FIXME - output assembler data??? */
/* output the table that contains the actual instruction info */
lf_printf (file, "%sitable_info %sitable[nr_%sitable_entries] = {\n",
options.module.itable.prefix.l,
- options.module.itable.prefix.l,
- options.module.itable.prefix.l);
+ options.module.itable.prefix.l, options.module.itable.prefix.l);
insn_table_traverse_insn (file, isa, itable_c_insn, NULL);
- lf_printf(file, "};\n");
+ lf_printf (file, "};\n");
}
/* Output a table of all the instructions */
-extern void gen_itable_h
-(lf *file,
- insn_table *table);
+extern void gen_itable_h (lf *file, insn_table *table);
-extern void gen_itable_c
-(lf *file,
- insn_table *table);
+extern void gen_itable_c (lf *file, insn_table *table);
#if 0
static void
-model_c_or_h_data(insn_table *table,
- lf *file,
- table_entry *data)
+model_c_or_h_data (insn_table *table, lf *file, table_entry *data)
{
- if (data->annex) {
- table_entry_print_cpp_line_nr(file, data->annex_line);
- lf_print__c_code(file, data->annex);
- lf_print__internal_reference(file);
- lf_printf(file, "\n");
- }
+ if (data->annex)
+ {
+ table_entry_print_cpp_line_nr (file, data->annex_line);
+ lf_print__c_code (file, data->annex);
+ lf_print__internal_reference (file);
+ lf_printf (file, "\n");
+ }
}
static void
-model_c_or_h_function(insn_table *entry,
- lf *file,
- table_entry *function,
- char *prefix)
+model_c_or_h_function (insn_table *entry,
+ lf *file, table_entry *function, char *prefix)
{
if (function->fields[function_type] == NULL
- || function->fields[function_type][0] == '\0') {
- error("Model function type not specified for %s", function->fields[function_name]);
- }
- lf_printf(file, "\n");
- lf_print_function_type(file, function->fields[function_type], prefix, " ");
- lf_printf(file, "%s\n(%s);\n",
- function->fields[function_name],
- function->fields[function_param]);
- lf_printf(file, "\n");
+ || function->fields[function_type][0] == '\0')
+ {
+ error ("Model function type not specified for %s",
+ function->fields[function_name]);
+ }
+ lf_printf (file, "\n");
+ lf_print_function_type (file, function->fields[function_type], prefix, " ");
+ lf_printf (file, "%s\n(%s);\n",
+ function->fields[function_name],
+ function->fields[function_param]);
+ lf_printf (file, "\n");
}
-void
-gen_model_h(insn_table *table, lf *file)
+void
+gen_model_h (insn_table *table, lf *file)
{
insn *insn_ptr;
model *model_ptr;
int model_mon_info_p = 0;
int model_mon_info_free_p = 0;
- for(macro = model_macros; macro; macro = macro->next) {
- model_c_or_h_data(table, file, macro->file_entry);
- }
-
- lf_printf(file, "typedef enum _model_enum {\n");
- lf_printf(file, " MODEL_NONE,\n");
- for (model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
- lf_printf(file, " MODEL_%s,\n", model_ptr->name);
- }
- lf_printf(file, " nr_models\n");
- lf_printf(file, "} model_enum;\n");
- lf_printf(file, "\n");
-
- lf_printf(file, "#define DEFAULT_MODEL MODEL_%s\n", (models) ? models->name : "NONE");
- lf_printf(file, "\n");
-
- lf_printf(file, "typedef struct _model_data model_data;\n");
- lf_printf(file, "typedef struct _model_time model_time;\n");
- lf_printf(file, "\n");
-
- lf_printf(file, "extern model_enum current_model;\n");
- lf_printf(file, "extern const char *model_name[ (int)nr_models ];\n");
- lf_printf(file, "extern const char *const *const model_func_unit_name[ (int)nr_models ];\n");
- lf_printf(file, "extern const model_time *const model_time_mapping[ (int)nr_models ];\n");
- lf_printf(file, "\n");
-
- for(insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next) {
- model_c_or_h_function(table, file, insn_ptr->file_entry, "INLINE_MODEL");
- name = insn_ptr->file_entry->fields[function_name];
- if (strcmp (name, "model_create") == 0)
- model_create_p = 1;
- else if (strcmp (name, "model_init") == 0)
- model_init_p = 1;
- else if (strcmp (name, "model_halt") == 0)
- model_halt_p = 1;
- else if (strcmp (name, "model_mon_info") == 0)
- model_mon_info_p = 1;
- else if (strcmp (name, "model_mon_info_free") == 0)
- model_mon_info_free_p = 1;
- }
-
- if (!model_create_p) {
- lf_print_function_type(file, "model_data *", "INLINE_MODEL", " ");
- lf_printf(file, "model_create\n");
- lf_printf(file, "(sim_cpu *cpu);\n");
- lf_printf(file, "\n");
- }
-
- if (!model_init_p) {
- lf_print_function_type(file, "void", "INLINE_MODEL", " ");
- lf_printf(file, "model_init\n");
- lf_printf(file, "(model_data *model_ptr);\n");
- lf_printf(file, "\n");
- }
-
- if (!model_halt_p) {
- lf_print_function_type(file, "void", "INLINE_MODEL", " ");
- lf_printf(file, "model_halt\n");
- lf_printf(file, "(model_data *model_ptr);\n");
- lf_printf(file, "\n");
- }
-
- if (!model_mon_info_p) {
- lf_print_function_type(file, "model_print *", "INLINE_MODEL", " ");
- lf_printf(file, "model_mon_info\n");
- lf_printf(file, "(model_data *model_ptr);\n");
- lf_printf(file, "\n");
- }
-
- if (!model_mon_info_free_p) {
- lf_print_function_type(file, "void", "INLINE_MODEL", " ");
- lf_printf(file, "model_mon_info_free\n");
- lf_printf(file, "(model_data *model_ptr,\n");
- lf_printf(file, " model_print *info_ptr);\n");
- lf_printf(file, "\n");
- }
-
- lf_print_function_type(file, "void", "INLINE_MODEL", " ");
- lf_printf(file, "model_set\n");
- lf_printf(file, "(const char *name);\n");
+ for (macro = model_macros; macro; macro = macro->next)
+ {
+ model_c_or_h_data (table, file, macro->file_entry);
+ }
+
+ lf_printf (file, "typedef enum _model_enum {\n");
+ lf_printf (file, " MODEL_NONE,\n");
+ for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
+ {
+ lf_printf (file, " MODEL_%s,\n", model_ptr->name);
+ }
+ lf_printf (file, " nr_models\n");
+ lf_printf (file, "} model_enum;\n");
+ lf_printf (file, "\n");
+
+ lf_printf (file, "#define DEFAULT_MODEL MODEL_%s\n",
+ (models) ? models->name : "NONE");
+ lf_printf (file, "\n");
+
+ lf_printf (file, "typedef struct _model_data model_data;\n");
+ lf_printf (file, "typedef struct _model_time model_time;\n");
+ lf_printf (file, "\n");
+
+ lf_printf (file, "extern model_enum current_model;\n");
+ lf_printf (file, "extern const char *model_name[ (int)nr_models ];\n");
+ lf_printf (file,
+ "extern const char *const *const model_func_unit_name[ (int)nr_models ];\n");
+ lf_printf (file,
+ "extern const model_time *const model_time_mapping[ (int)nr_models ];\n");
+ lf_printf (file, "\n");
+
+ for (insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next)
+ {
+ model_c_or_h_function (table, file, insn_ptr->file_entry,
+ "INLINE_MODEL");
+ name = insn_ptr->file_entry->fields[function_name];
+ if (strcmp (name, "model_create") == 0)
+ model_create_p = 1;
+ else if (strcmp (name, "model_init") == 0)
+ model_init_p = 1;
+ else if (strcmp (name, "model_halt") == 0)
+ model_halt_p = 1;
+ else if (strcmp (name, "model_mon_info") == 0)
+ model_mon_info_p = 1;
+ else if (strcmp (name, "model_mon_info_free") == 0)
+ model_mon_info_free_p = 1;
+ }
+
+ if (!model_create_p)
+ {
+ lf_print_function_type (file, "model_data *", "INLINE_MODEL", " ");
+ lf_printf (file, "model_create\n");
+ lf_printf (file, "(sim_cpu *cpu);\n");
+ lf_printf (file, "\n");
+ }
+
+ if (!model_init_p)
+ {
+ lf_print_function_type (file, "void", "INLINE_MODEL", " ");
+ lf_printf (file, "model_init\n");
+ lf_printf (file, "(model_data *model_ptr);\n");
+ lf_printf (file, "\n");
+ }
+
+ if (!model_halt_p)
+ {
+ lf_print_function_type (file, "void", "INLINE_MODEL", " ");
+ lf_printf (file, "model_halt\n");
+ lf_printf (file, "(model_data *model_ptr);\n");
+ lf_printf (file, "\n");
+ }
+
+ if (!model_mon_info_p)
+ {
+ lf_print_function_type (file, "model_print *", "INLINE_MODEL", " ");
+ lf_printf (file, "model_mon_info\n");
+ lf_printf (file, "(model_data *model_ptr);\n");
+ lf_printf (file, "\n");
+ }
+
+ if (!model_mon_info_free_p)
+ {
+ lf_print_function_type (file, "void", "INLINE_MODEL", " ");
+ lf_printf (file, "model_mon_info_free\n");
+ lf_printf (file, "(model_data *model_ptr,\n");
+ lf_printf (file, " model_print *info_ptr);\n");
+ lf_printf (file, "\n");
+ }
+
+ lf_print_function_type (file, "void", "INLINE_MODEL", " ");
+ lf_printf (file, "model_set\n");
+ lf_printf (file, "(const char *name);\n");
}
/****************************************************************/
typedef struct _model_c_passed_data model_c_passed_data;
-struct _model_c_passed_data {
+struct _model_c_passed_data
+{
lf *file;
model *model_ptr;
};
static void
-model_c_insn(insn_table *entry,
- lf *phony_file,
- void *data,
- insn *instruction,
- int depth)
+model_c_insn (insn_table *entry,
+ lf *phony_file, void *data, insn * instruction, int depth)
{
- model_c_passed_data *data_ptr = (model_c_passed_data *)data;
+ model_c_passed_data *data_ptr = (model_c_passed_data *) data;
lf *file = data_ptr->file;
char *current_name = data_ptr->model_ptr->printable_name;
table_model_entry *model_ptr = instruction->file_entry->model_first;
- while (model_ptr) {
- if (model_ptr->fields[insn_model_name] == current_name) {
- lf_printf(file, " { %-*s }, /* %s */\n",
- max_model_fields_len,
- model_ptr->fields[insn_model_fields],
- instruction->file_entry->fields[insn_name]);
- return;
+ while (model_ptr)
+ {
+ if (model_ptr->fields[insn_model_name] == current_name)
+ {
+ lf_printf (file, " { %-*s }, /* %s */\n",
+ max_model_fields_len,
+ model_ptr->fields[insn_model_fields],
+ instruction->file_entry->fields[insn_name]);
+ return;
+ }
+
+ model_ptr = model_ptr->next;
}
- model_ptr = model_ptr->next;
- }
-
- lf_printf(file, " { %-*s }, /* %s */\n",
- max_model_fields_len,
- data_ptr->model_ptr->insn_default,
- instruction->file_entry->fields[insn_name]);
+ lf_printf (file, " { %-*s }, /* %s */\n",
+ max_model_fields_len,
+ data_ptr->model_ptr->insn_default,
+ instruction->file_entry->fields[insn_name]);
}
static void
-model_c_function(insn_table *table,
- lf *file,
- table_entry *function,
- const char *prefix)
+model_c_function (insn_table *table,
+ lf *file, table_entry *function, const char *prefix)
{
if (function->fields[function_type] == NULL
|| function->fields[function_type][0] == '\0')
{
- error("Model function return type not specified for %s",
- function->fields[function_name]);
+ error ("Model function return type not specified for %s",
+ function->fields[function_name]);
}
else
{
- lf_printf(file, "\n");
- lf_print_function_type(file, function->fields[function_type], prefix, "\n");
- lf_printf(file, "%s(%s)\n",
- function->fields[function_name],
- function->fields[function_param]);
+ lf_printf (file, "\n");
+ lf_print_function_type (file, function->fields[function_type], prefix,
+ "\n");
+ lf_printf (file, "%s(%s)\n", function->fields[function_name],
+ function->fields[function_param]);
}
- lf_printf(file, "{\n");
+ lf_printf (file, "{\n");
if (function->annex)
{
- lf_indent(file, +2);
- table_entry_print_cpp_line_nr(file, function->annex_line);
- lf_print__c_code(file, function->annex);
- lf_indent(file, -2);
+ lf_indent (file, +2);
+ table_entry_print_cpp_line_nr (file, function->annex_line);
+ lf_print__c_code (file, function->annex);
+ lf_indent (file, -2);
}
- lf_printf(file, "}\n");
- lf_print__internal_reference(file);
- lf_printf(file, "\n");
+ lf_printf (file, "}\n");
+ lf_print__internal_reference (file);
+ lf_printf (file, "\n");
}
-void
-gen_model_c(insn_table *table, lf *file)
+void
+gen_model_c (insn_table *table, lf *file)
{
insn *insn_ptr;
model *model_ptr;
int model_mon_info_p = 0;
int model_mon_info_free_p = 0;
- lf_printf(file, "\n");
- lf_printf(file, "#include \"cpu.h\"\n");
- lf_printf(file, "#include \"mon.h\"\n");
- lf_printf(file, "\n");
- lf_printf(file, "#ifdef HAVE_STDLIB_H\n");
- lf_printf(file, "#include <stdlib.h>\n");
- lf_printf(file, "#endif\n");
- lf_printf(file, "\n");
-
- for(insn_ptr = model_data; insn_ptr; insn_ptr = insn_ptr->next) {
- model_c_or_h_data(table, file, insn_ptr->file_entry);
- }
-
- for(insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next) {
- model_c_or_h_function(table, file, insn_ptr->file_entry, "/*h*/STATIC");
- }
-
- for(insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next) {
- model_c_or_h_function(table, file, insn_ptr->file_entry, "STATIC_INLINE_MODEL");
- }
-
- for(insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next) {
- model_c_function(table, file, insn_ptr->file_entry, "/*c*/STATIC");
- }
-
- for(insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next) {
- model_c_function(table, file, insn_ptr->file_entry, "STATIC_INLINE_MODEL");
- }
-
- for(insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next) {
- model_c_function(table, file, insn_ptr->file_entry, "INLINE_MODEL");
- name = insn_ptr->file_entry->fields[function_name];
- if (strcmp (name, "model_create") == 0)
- model_create_p = 1;
- else if (strcmp (name, "model_init") == 0)
- model_init_p = 1;
- else if (strcmp (name, "model_halt") == 0)
- model_halt_p = 1;
- else if (strcmp (name, "model_mon_info") == 0)
- model_mon_info_p = 1;
- else if (strcmp (name, "model_mon_info_free") == 0)
- model_mon_info_free_p = 1;
- }
-
- if (!model_create_p) {
- lf_print_function_type(file, "model_data *", "INLINE_MODEL", "\n");
- lf_printf(file, "model_create(sim_cpu *cpu)\n");
- lf_printf(file, "{\n");
- lf_printf(file, " return (model_data *)0;\n");
- lf_printf(file, "}\n");
- lf_printf(file, "\n");
- }
-
- if (!model_init_p) {
- lf_print_function_type(file, "void", "INLINE_MODEL", "\n");
- lf_printf(file, "model_init(model_data *model_ptr)\n");
- lf_printf(file, "{\n");
- lf_printf(file, "}\n");
- lf_printf(file, "\n");
- }
-
- if (!model_halt_p) {
- lf_print_function_type(file, "void", "INLINE_MODEL", "\n");
- lf_printf(file, "model_halt(model_data *model_ptr)\n");
- lf_printf(file, "{\n");
- lf_printf(file, "}\n");
- lf_printf(file, "\n");
- }
-
- if (!model_mon_info_p) {
- lf_print_function_type(file, "model_print *", "INLINE_MODEL", "\n");
- lf_printf(file, "model_mon_info(model_data *model_ptr)\n");
- lf_printf(file, "{\n");
- lf_printf(file, " return (model_print *)0;\n");
- lf_printf(file, "}\n");
- lf_printf(file, "\n");
- }
-
- if (!model_mon_info_free_p) {
- lf_print_function_type(file, "void", "INLINE_MODEL", "\n");
- lf_printf(file, "model_mon_info_free(model_data *model_ptr,\n");
- lf_printf(file, " model_print *info_ptr)\n");
- lf_printf(file, "{\n");
- lf_printf(file, "}\n");
- lf_printf(file, "\n");
- }
-
- lf_printf(file, "/* Insn functional unit info */\n");
- for(model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
- model_c_passed_data data;
-
- lf_printf(file, "static const model_time model_time_%s[] = {\n", model_ptr->name);
- data.file = file;
- data.model_ptr = model_ptr;
- insn_table_traverse_insn(table,
- NULL, (void *)&data,
- model_c_insn);
-
- lf_printf(file, "};\n");
- lf_printf(file, "\n");
- lf_printf(file, "\f\n");
- }
-
- lf_printf(file, "#ifndef _INLINE_C_\n");
- lf_printf(file, "const model_time *const model_time_mapping[ (int)nr_models ] = {\n");
- lf_printf(file, " (const model_time *const)0,\n");
- for(model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
- lf_printf(file, " model_time_%s,\n", model_ptr->name);
- }
- lf_printf(file, "};\n");
- lf_printf(file, "#endif\n");
- lf_printf(file, "\n");
-
- lf_printf(file, "\f\n");
- lf_printf(file, "/* map model enumeration into printable string */\n");
- lf_printf(file, "#ifndef _INLINE_C_\n");
- lf_printf(file, "const char *model_name[ (int)nr_models ] = {\n");
- lf_printf(file, " \"NONE\",\n");
- for (model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
- lf_printf(file, " \"%s\",\n", model_ptr->printable_name);
- }
- lf_printf(file, "};\n");
- lf_printf(file, "#endif\n");
- lf_printf(file, "\n");
-
- lf_print_function_type(file, "void", "INLINE_MODEL", "\n");
- lf_printf(file, "model_set(const char *name)\n");
- lf_printf(file, "{\n");
- if (models) {
- lf_printf(file, " model_enum model;\n");
- lf_printf(file, " for(model = MODEL_%s; model < nr_models; model++) {\n", models->name);
- lf_printf(file, " if(strcmp(name, model_name[model]) == 0) {\n");
- lf_printf(file, " current_model = model;\n");
- lf_printf(file, " return;\n");
- lf_printf(file, " }\n");
- lf_printf(file, " }\n");
- lf_printf(file, "\n");
- lf_printf(file, " error(\"Unknown model '%%s', Models which are known are:%%s\n\",\n");
- lf_printf(file, " name,\n");
- lf_printf(file, " \"");
- for(model_ptr = models; model_ptr; model_ptr = model_ptr->next) {
- lf_printf(file, "\\n\\t%s", model_ptr->printable_name);
+ lf_printf (file, "\n");
+ lf_printf (file, "#include \"cpu.h\"\n");
+ lf_printf (file, "#include \"mon.h\"\n");
+ lf_printf (file, "\n");
+ lf_printf (file, "#ifdef HAVE_STDLIB_H\n");
+ lf_printf (file, "#include <stdlib.h>\n");
+ lf_printf (file, "#endif\n");
+ lf_printf (file, "\n");
+
+ for (insn_ptr = model_data; insn_ptr; insn_ptr = insn_ptr->next)
+ {
+ model_c_or_h_data (table, file, insn_ptr->file_entry);
+ }
+
+ for (insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next)
+ {
+ model_c_or_h_function (table, file, insn_ptr->file_entry,
+ "/*h*/STATIC");
+ }
+
+ for (insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next)
+ {
+ model_c_or_h_function (table, file, insn_ptr->file_entry,
+ "STATIC_INLINE_MODEL");
+ }
+
+ for (insn_ptr = model_static; insn_ptr; insn_ptr = insn_ptr->next)
+ {
+ model_c_function (table, file, insn_ptr->file_entry, "/*c*/STATIC");
+ }
+
+ for (insn_ptr = model_internal; insn_ptr; insn_ptr = insn_ptr->next)
+ {
+ model_c_function (table, file, insn_ptr->file_entry,
+ "STATIC_INLINE_MODEL");
+ }
+
+ for (insn_ptr = model_functions; insn_ptr; insn_ptr = insn_ptr->next)
+ {
+ model_c_function (table, file, insn_ptr->file_entry, "INLINE_MODEL");
+ name = insn_ptr->file_entry->fields[function_name];
+ if (strcmp (name, "model_create") == 0)
+ model_create_p = 1;
+ else if (strcmp (name, "model_init") == 0)
+ model_init_p = 1;
+ else if (strcmp (name, "model_halt") == 0)
+ model_halt_p = 1;
+ else if (strcmp (name, "model_mon_info") == 0)
+ model_mon_info_p = 1;
+ else if (strcmp (name, "model_mon_info_free") == 0)
+ model_mon_info_free_p = 1;
+ }
+
+ if (!model_create_p)
+ {
+ lf_print_function_type (file, "model_data *", "INLINE_MODEL", "\n");
+ lf_printf (file, "model_create(sim_cpu *cpu)\n");
+ lf_printf (file, "{\n");
+ lf_printf (file, " return (model_data *)0;\n");
+ lf_printf (file, "}\n");
+ lf_printf (file, "\n");
+ }
+
+ if (!model_init_p)
+ {
+ lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
+ lf_printf (file, "model_init(model_data *model_ptr)\n");
+ lf_printf (file, "{\n");
+ lf_printf (file, "}\n");
+ lf_printf (file, "\n");
+ }
+
+ if (!model_halt_p)
+ {
+ lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
+ lf_printf (file, "model_halt(model_data *model_ptr)\n");
+ lf_printf (file, "{\n");
+ lf_printf (file, "}\n");
+ lf_printf (file, "\n");
+ }
+
+ if (!model_mon_info_p)
+ {
+ lf_print_function_type (file, "model_print *", "INLINE_MODEL", "\n");
+ lf_printf (file, "model_mon_info(model_data *model_ptr)\n");
+ lf_printf (file, "{\n");
+ lf_printf (file, " return (model_print *)0;\n");
+ lf_printf (file, "}\n");
+ lf_printf (file, "\n");
+ }
+
+ if (!model_mon_info_free_p)
+ {
+ lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
+ lf_printf (file, "model_mon_info_free(model_data *model_ptr,\n");
+ lf_printf (file, " model_print *info_ptr)\n");
+ lf_printf (file, "{\n");
+ lf_printf (file, "}\n");
+ lf_printf (file, "\n");
+ }
+
+ lf_printf (file, "/* Insn functional unit info */\n");
+ for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
+ {
+ model_c_passed_data data;
+
+ lf_printf (file, "static const model_time model_time_%s[] = {\n",
+ model_ptr->name);
+ data.file = file;
+ data.model_ptr = model_ptr;
+ insn_table_traverse_insn (table, NULL, (void *) &data, model_c_insn);
+
+ lf_printf (file, "};\n");
+ lf_printf (file, "\n");
+ lf_printf (file, "\f\n");
+ }
+
+ lf_printf (file, "#ifndef _INLINE_C_\n");
+ lf_printf (file,
+ "const model_time *const model_time_mapping[ (int)nr_models ] = {\n");
+ lf_printf (file, " (const model_time *const)0,\n");
+ for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
+ {
+ lf_printf (file, " model_time_%s,\n", model_ptr->name);
+ }
+ lf_printf (file, "};\n");
+ lf_printf (file, "#endif\n");
+ lf_printf (file, "\n");
+
+ lf_printf (file, "\f\n");
+ lf_printf (file, "/* map model enumeration into printable string */\n");
+ lf_printf (file, "#ifndef _INLINE_C_\n");
+ lf_printf (file, "const char *model_name[ (int)nr_models ] = {\n");
+ lf_printf (file, " \"NONE\",\n");
+ for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
+ {
+ lf_printf (file, " \"%s\",\n", model_ptr->printable_name);
+ }
+ lf_printf (file, "};\n");
+ lf_printf (file, "#endif\n");
+ lf_printf (file, "\n");
+
+ lf_print_function_type (file, "void", "INLINE_MODEL", "\n");
+ lf_printf (file, "model_set(const char *name)\n");
+ lf_printf (file, "{\n");
+ if (models)
+ {
+ lf_printf (file, " model_enum model;\n");
+ lf_printf (file,
+ " for(model = MODEL_%s; model < nr_models; model++) {\n",
+ models->name);
+ lf_printf (file, " if(strcmp(name, model_name[model]) == 0) {\n");
+ lf_printf (file, " current_model = model;\n");
+ lf_printf (file, " return;\n");
+ lf_printf (file, " }\n");
+ lf_printf (file, " }\n");
+ lf_printf (file, "\n");
+ lf_printf (file,
+ " error(\"Unknown model '%%s', Models which are known are:%%s\n\",\n");
+ lf_printf (file, " name,\n");
+ lf_printf (file, " \"");
+ for (model_ptr = models; model_ptr; model_ptr = model_ptr->next)
+ {
+ lf_printf (file, "\\n\\t%s", model_ptr->printable_name);
+ }
+ lf_printf (file, "\");\n");
+ }
+ else
+ {
+ lf_printf (file, " error(\"No models are currently known about\");\n");
}
- lf_printf(file, "\");\n");
- } else {
- lf_printf(file, " error(\"No models are currently known about\");\n");
- }
- lf_printf(file, "}\n");
+ lf_printf (file, "}\n");
}
#endif
void
-gen_model_h (lf *file,
- insn_table *table)
+gen_model_h (lf *file, insn_table *table)
{
lf_print__this_file_is_empty (file, "suffering bit rot");
}
void
-gen_model_c (lf *file,
- insn_table *table)
+gen_model_c (lf *file, insn_table *table)
{
lf_print__this_file_is_empty (file, "suffering bit rot");
}
-extern void gen_model_h
-(lf *file,
- insn_table *isa);
+extern void gen_model_h (lf *file, insn_table *isa);
-extern void gen_model_c
-(lf *file,
- insn_table *isa);
+extern void gen_model_c (lf *file, insn_table *isa);
int nr_prefetched_words)
{
int indent;
- lf_printf(file, "\n");
+ lf_printf (file, "\n");
lf_print__function_type_function (file, print_semantic_function_type,
"EXTERN_SEMANTICS",
(is_function_definition ? "\n" : " "));
void
print_semantic_declaration (lf *file,
- insn_entry *insn,
+ insn_entry * insn,
opcode_bits *expanded_bits,
- insn_opcodes *opcodes,
- int nr_prefetched_words)
+ insn_opcodes *opcodes, int nr_prefetched_words)
{
print_semantic_function_header (file,
insn->name,
insn->format_name,
expanded_bits,
- 0/* is not function definition*/,
+ 0 /* is not function definition */ ,
nr_prefetched_words);
}
+\f
-\f
/* generate the semantics.c file */
void
-print_idecode_invalid (lf *file,
- const char *result,
- invalid_type type)
+print_idecode_invalid (lf *file, const char *result, invalid_type type)
{
const char *name;
switch (type)
{
- default: name = "unknown"; break;
- case invalid_illegal: name = "illegal"; break;
- case invalid_fp_unavailable: name = "fp_unavailable"; break;
- case invalid_wrong_slot: name = "wrong_slot"; break;
+ default:
+ name = "unknown";
+ break;
+ case invalid_illegal:
+ name = "illegal";
+ break;
+ case invalid_fp_unavailable:
+ name = "fp_unavailable";
+ break;
+ case invalid_wrong_slot:
+ name = "wrong_slot";
+ break;
}
if (options.gen.code == generate_jumps)
{
lf_printf (file, "goto %s_%s;\n",
- (options.gen.icache ? "icache" : "semantic"),
- name);
+ (options.gen.icache ? "icache" : "semantic"), name);
}
else if (options.gen.icache)
{
- lf_printf (file, "%s %sicache_%s (", result, options.module.global.prefix.l, name);
+ lf_printf (file, "%s %sicache_%s (", result,
+ options.module.global.prefix.l, name);
print_icache_function_actual (file, 0);
lf_printf (file, ");\n");
}
else
{
- lf_printf (file, "%s %ssemantic_%s (", result, options.module.global.prefix.l, name);
+ lf_printf (file, "%s %ssemantic_%s (", result,
+ options.module.global.prefix.l, name);
print_semantic_function_actual (file, 0);
lf_printf (file, ");\n");
}
void
print_semantic_body (lf *file,
- insn_entry *instruction,
- opcode_bits *expanded_bits,
- insn_opcodes *opcodes)
+ insn_entry * instruction,
+ opcode_bits *expanded_bits, insn_opcodes *opcodes)
{
/* validate the instruction, if a cache this has already been done */
if (!options.gen.icache)
{
print_idecode_validate (file, instruction, opcodes);
}
-
- print_itrace (file, instruction, 0/*put_value_in_cache*/);
-
+
+ print_itrace (file, instruction, 0 /*put_value_in_cache */ );
+
/* generate the instruction profile call - this is delayed until
after the instruction has been verified. The count macro
generated is prefixed by ITABLE_PREFIX */
print_function_name (file,
instruction->name,
instruction->format_name,
- NULL,
- NULL,
- function_name_prefix_itable);
+ NULL, NULL, function_name_prefix_itable);
lf_printf (file, ", cpu, cia);\n");
lf_indent_suppress (file);
lf_printf (file, "#endif\n");
lf_printf (file, "\n");
}
-
+
/* determine the new instruction address */
{
- lf_printf(file, "/* keep the next instruction address handy */\n");
+ lf_printf (file, "/* keep the next instruction address handy */\n");
if (options.gen.nia == nia_is_invalid)
{
- lf_printf(file, "nia = %sINVALID_INSTRUCTION_ADDRESS;\n",
- options.module.global.prefix.u);
+ lf_printf (file, "nia = %sINVALID_INSTRUCTION_ADDRESS;\n",
+ options.module.global.prefix.u);
}
else
{
lf_printf (file, "nia = cia + %d * (%d + 1); %s\n",
options.insn_bit_size / 8, nr_immeds,
"/* skip immeds as well */");
-
+
}
else
{
}
}
}
-
+
/* if conditional, generate code to verify that the instruction
should be issued */
if (filter_is_member (instruction->options, "c")
lf_indent (file, +4);
/* FIXME - need to log a conditional failure */
}
-
+
/* Architecture expects a REG to be zero. Instead of having to
check every read to see if it is refering to that REG just zap it
at the start of every instruction */
lf_printf (file, "/* Architecture expects REG to be zero */\n");
lf_printf (file, "GPR_CLEAR(%d);\n", options.gen.zero_reg_nr);
}
-
+
/* generate the code (or at least something */
lf_printf (file, "\n");
lf_printf (file, "/* semantics: */\n");
lf_indent (file, -indent);
lf_print__internal_ref (file);
}
-
+
/* Close off the conditional execution */
if (filter_is_member (instruction->options, "c")
|| options.gen.conditional_issue)
{
lf_indent (file, -4);
lf_printf (file, " }\n");
- }
+ }
}
static void
print_c_semantic (lf *file,
- insn_entry *instruction,
+ insn_entry * instruction,
opcode_bits *expanded_bits,
insn_opcodes *opcodes,
- cache_entry *cache_rules,
- int nr_prefetched_words)
+ cache_entry *cache_rules, int nr_prefetched_words)
{
-
+
lf_printf (file, "{\n");
lf_indent (file, +2);
-
+
print_my_defines (file,
instruction->name,
- instruction->format_name,
- expanded_bits);
+ instruction->format_name, expanded_bits);
lf_printf (file, "\n");
print_icache_body (file,
instruction,
: declare_variables),
(options.gen.icache
? get_values_from_icache
- : do_not_use_icache),
- nr_prefetched_words);
-
- lf_printf (file, "%sinstruction_address nia;\n", options.module.global.prefix.l);
- print_semantic_body (file,
- instruction,
- expanded_bits,
- opcodes);
+ : do_not_use_icache), nr_prefetched_words);
+
+ lf_printf (file, "%sinstruction_address nia;\n",
+ options.module.global.prefix.l);
+ print_semantic_body (file, instruction, expanded_bits, opcodes);
lf_printf (file, "return nia;\n");
-
+
/* generate something to clean up any #defines created for the cache */
if (options.gen.direct_access)
{
undef_variables,
(options.gen.icache
? get_values_from_icache
- : do_not_use_icache),
- nr_prefetched_words);
+ : do_not_use_icache), nr_prefetched_words);
}
-
+
lf_indent (file, -2);
lf_printf (file, "}\n");
}
static void
print_c_semantic_function (lf *file,
- insn_entry *instruction,
+ insn_entry * instruction,
opcode_bits *expanded_bits,
insn_opcodes *opcodes,
- cache_entry *cache_rules,
- int nr_prefetched_words)
+ cache_entry *cache_rules, int nr_prefetched_words)
{
/* build the semantic routine to execute the instruction */
print_semantic_function_header (file,
instruction->name,
instruction->format_name,
expanded_bits,
- 1/*is-function-definition*/,
+ 1 /*is-function-definition */ ,
nr_prefetched_words);
print_c_semantic (file,
instruction,
- expanded_bits,
- opcodes,
- cache_rules,
- nr_prefetched_words);
+ expanded_bits, opcodes, cache_rules, nr_prefetched_words);
}
void
print_semantic_definition (lf *file,
- insn_entry *insn,
+ insn_entry * insn,
opcode_bits *expanded_bits,
insn_opcodes *opcodes,
- cache_entry *cache_rules,
- int nr_prefetched_words)
+ cache_entry *cache_rules, int nr_prefetched_words)
{
print_c_semantic_function (file,
insn,
expanded_bits,
- opcodes,
- cache_rules,
- nr_prefetched_words);
+ opcodes, cache_rules, nr_prefetched_words);
}
-
-
extern void print_semantic_declaration
-(lf *file,
- insn_entry *insn,
- opcode_bits *bits,
- insn_opcodes *opcodes,
- int nr_prefetched_words);
+ (lf *file,
+ insn_entry * insn,
+ opcode_bits *bits, insn_opcodes *opcodes, int nr_prefetched_words);
extern void print_semantic_definition
-(lf *file,
- insn_entry *insn,
- opcode_bits *bits,
- insn_opcodes *opcodes,
- cache_entry *cache_rules,
- int nr_prefetched_words);
+ (lf *file,
+ insn_entry * insn,
+ opcode_bits *bits,
+ insn_opcodes *opcodes, cache_entry *cache_rules, int nr_prefetched_words);
-typedef enum {
+typedef enum
+{
invalid_illegal,
invalid_fp_unavailable,
invalid_wrong_slot,
-} invalid_type;
+}
+invalid_type;
extern void print_idecode_invalid
-(lf *file,
- const char *result,
- invalid_type type);
+ (lf *file, const char *result, invalid_type type);
extern void print_semantic_body
-(lf *file,
- insn_entry *instruction,
- opcode_bits *expanded_bits,
- insn_opcodes *opcodes);
-
+ (lf *file,
+ insn_entry * instruction,
+ opcode_bits *expanded_bits, insn_opcodes *opcodes);
static void
print_support_function_name (lf *file,
- function_entry *function,
+ function_entry * function,
int is_function_definition)
{
if (function->is_internal)
{
lf_print__function_type_function (file, print_semantic_function_type,
"INLINE_SUPPORT",
- (is_function_definition ? "\n" : " "));
- print_function_name (file,
- function->name,
- NULL,
- NULL,
- NULL,
+ (is_function_definition ? "\n" :
+ " "));
+ print_function_name (file, function->name, NULL, NULL, NULL,
function_name_prefix_semantics);
lf_printf (file, "\n(");
lf_indent (file, +1);
lf_indent_suppress (file);
lf_printf (file, "#define %s %s%s\n",
function->name,
- options.module.support.prefix.l,
- function->name);
+ options.module.support.prefix.l, function->name);
}
lf_print__function_type (file,
function->type,
"INLINE_SUPPORT",
(is_function_definition ? "\n" : " "));
lf_printf (file, "%s%s\n(",
- options.module.support.prefix.l,
- function->name);
+ options.module.support.prefix.l, function->name);
if (options.gen.smp)
lf_printf (file,
"sim_cpu *cpu, %sinstruction_address cia, int MY_INDEX",
lf_printf (file,
"SIM_DESC sd, %sinstruction_address cia, int MY_INDEX",
options.module.support.prefix.l);
- if (function->param != NULL
- && strlen (function->param) > 0)
+ if (function->param != NULL && strlen (function->param) > 0)
lf_printf (file, ", %s", function->param);
lf_printf (file, ")%s", (is_function_definition ? "\n" : ";\n"));
}
static void
-support_h_function (lf *file,
- function_entry *function,
- void *data)
+support_h_function (lf *file, function_entry * function, void *data)
{
ASSERT (function->type != NULL);
- print_support_function_name (file,
- function,
- 0/*!is_definition*/);
- lf_printf(file, "\n");
+ print_support_function_name (file, function, 0 /*!is_definition */ );
+ lf_printf (file, "\n");
}
extern void
-gen_support_h (lf *file,
- insn_table *table)
+gen_support_h (lf *file, insn_table *table)
{
- /* output the definition of `SD_'*/
- if (options.gen.smp)
+ /* output the definition of `SD_' */
+ if (options.gen.smp)
{
- lf_printf(file, "#define SD CPU_STATE (cpu)\n");
- lf_printf(file, "#define CPU cpu\n");
- lf_printf(file, "#define CPU_ cpu\n");
+ lf_printf (file, "#define SD CPU_STATE (cpu)\n");
+ lf_printf (file, "#define CPU cpu\n");
+ lf_printf (file, "#define CPU_ cpu\n");
}
else
{
- lf_printf(file, "#define SD sd\n");
- lf_printf(file, "#define CPU (STATE_CPU (sd, 0))\n");
- lf_printf(file, "#define CPU_ sd\n");
+ lf_printf (file, "#define SD sd\n");
+ lf_printf (file, "#define CPU (STATE_CPU (sd, 0))\n");
+ lf_printf (file, "#define CPU_ sd\n");
}
- lf_printf(file, "#define CIA_ cia\n");
+ lf_printf (file, "#define CIA_ cia\n");
if (options.gen.delayed_branch)
{
- lf_printf(file, "#define CIA cia.ip\n");
- lf_printf(file, "/* #define NIA nia.dp -- do not define, ambigious */\n");
+ lf_printf (file, "#define CIA cia.ip\n");
+ lf_printf (file,
+ "/* #define NIA nia.dp -- do not define, ambigious */\n");
}
else
{
- lf_printf(file, "#define CIA cia\n");
- lf_printf(file, "#define NIA nia\n");
+ lf_printf (file, "#define CIA cia\n");
+ lf_printf (file, "#define NIA nia\n");
}
- lf_printf(file, "\n");
+ lf_printf (file, "\n");
- lf_printf(file, "#define SD_ CPU_, CIA_, MY_INDEX\n");
- lf_printf(file, "#define _SD SD_ /* deprecated */\n");
- lf_printf(file, "\n");
+ lf_printf (file, "#define SD_ CPU_, CIA_, MY_INDEX\n");
+ lf_printf (file, "#define _SD SD_ /* deprecated */\n");
+ lf_printf (file, "\n");
/* Map <PREFIX>_xxxx onto the shorter xxxx for the following names:
- instruction_word
- idecode_issue
- semantic_illegal
+ instruction_word
+ idecode_issue
+ semantic_illegal
Map defined here as name space problems are created when the name is
defined in idecode.h */
lf_indent_suppress (file);
lf_printf (file, "#define %s %s%s\n",
"instruction_word",
- options.module.idecode.prefix.l,
- "instruction_word");
+ options.module.idecode.prefix.l, "instruction_word");
lf_printf (file, "\n");
lf_indent_suppress (file);
lf_printf (file, "#define %s %s%s\n",
"idecode_issue",
- options.module.idecode.prefix.l,
- "idecode_issue");
+ options.module.idecode.prefix.l, "idecode_issue");
lf_printf (file, "\n");
lf_indent_suppress (file);
lf_printf (file, "#define %s %s%s\n",
"semantic_illegal",
- options.module.idecode.prefix.l,
- "semantic_illegal");
+ options.module.idecode.prefix.l, "semantic_illegal");
lf_printf (file, "\n");
}
/* output a declaration for all functions */
- function_entry_traverse (file, table->functions,
- support_h_function,
- NULL);
- lf_printf(file, "\n");
- lf_printf(file, "#if defined(SUPPORT_INLINE)\n");
- lf_printf(file, "# if ((SUPPORT_INLINE & INCLUDE_MODULE)\\\n");
- lf_printf(file, " && (SUPPORT_INLINE & INCLUDED_BY_MODULE))\n");
- lf_printf(file, "# include \"%ssupport.c\"\n", options.module.support.prefix.l);
- lf_printf(file, "# endif\n");
- lf_printf(file, "#endif\n");
+ function_entry_traverse (file, table->functions, support_h_function, NULL);
+ lf_printf (file, "\n");
+ lf_printf (file, "#if defined(SUPPORT_INLINE)\n");
+ lf_printf (file, "# if ((SUPPORT_INLINE & INCLUDE_MODULE)\\\n");
+ lf_printf (file, " && (SUPPORT_INLINE & INCLUDED_BY_MODULE))\n");
+ lf_printf (file, "# include \"%ssupport.c\"\n",
+ options.module.support.prefix.l);
+ lf_printf (file, "# endif\n");
+ lf_printf (file, "#endif\n");
}
static void
-support_c_function (lf *file,
- function_entry *function,
- void *data)
+support_c_function (lf *file, function_entry * function, void *data)
{
ASSERT (function->type != NULL);
- print_support_function_name (file,
- function,
- 1/*!is_definition*/);
+ print_support_function_name (file, function, 1 /*!is_definition */ );
lf_printf (file, "{\n");
lf_indent (file, +2);
if (function->code == NULL)
- error (function->line,
- "Function without body (or null statement)");
+ error (function->line, "Function without body (or null statement)");
lf_print__line_ref (file, function->code->line);
table_print_code (file, function->code);
if (function->is_internal)
{
- lf_printf (file, "sim_engine_abort (SD, CPU, cia, \"Internal function must longjump\\n\");\n");
+ lf_printf (file,
+ "sim_engine_abort (SD, CPU, cia, \"Internal function must longjump\\n\");\n");
lf_printf (file, "return cia;\n");
}
lf_indent (file, -2);
void
-gen_support_c (lf *file,
- insn_table *table)
+gen_support_c (lf *file, insn_table *table)
{
- lf_printf(file, "#include \"sim-main.h\"\n");
- lf_printf(file, "#include \"%sidecode.h\"\n", options.module.idecode.prefix.l);
- lf_printf(file, "#include \"%sitable.h\"\n", options.module.itable.prefix.l);
- lf_printf(file, "#include \"%ssupport.h\"\n", options.module.support.prefix.l);
- lf_printf(file, "\n");
+ lf_printf (file, "#include \"sim-main.h\"\n");
+ lf_printf (file, "#include \"%sidecode.h\"\n",
+ options.module.idecode.prefix.l);
+ lf_printf (file, "#include \"%sitable.h\"\n",
+ options.module.itable.prefix.l);
+ lf_printf (file, "#include \"%ssupport.h\"\n",
+ options.module.support.prefix.l);
+ lf_printf (file, "\n");
/* output a definition (c-code) for all functions */
- function_entry_traverse (file, table->functions,
- support_c_function,
- NULL);
+ function_entry_traverse (file, table->functions, support_c_function, NULL);
}
Boston, MA 02111-1307, USA. */
-extern void gen_support_h
-(lf *file,
- insn_table *table);
-
-extern void gen_support_c
-(lf *file,
- insn_table *table);
+extern void gen_support_h (lf *file, insn_table *table);
+extern void gen_support_c (lf *file, insn_table *table);
#include "gen.h"
static insn_uint
-sub_val (insn_uint val,
- int val_last_pos,
- int first_pos,
- int last_pos)
+sub_val (insn_uint val, int val_last_pos, int first_pos, int last_pos)
{
return ((val >> (val_last_pos - last_pos))
- & (((insn_uint)1 << (last_pos - first_pos + 1)) - 1));
+ & (((insn_uint) 1 << (last_pos - first_pos + 1)) - 1));
}
static void
-update_depth (lf *file,
- gen_entry *entry,
- int depth,
- void *data)
+update_depth (lf *file, gen_entry *entry, int depth, void *data)
{
- int *max_depth = (int*)data;
+ int *max_depth = (int *) data;
if (*max_depth < depth)
*max_depth = depth;
}
gen_entry_depth (gen_entry *table)
{
int depth = 0;
- gen_entry_traverse_tree (NULL,
- table,
- 1,
- NULL, /*start*/
- update_depth,
- NULL, /*end*/
- &depth); /* data */
+ gen_entry_traverse_tree (NULL, table, 1, NULL, /*start */
+ update_depth, NULL, /*end */
+ &depth); /* data */
return depth;
}
static void
-print_gen_entry_path (line_ref *line,
- gen_entry *table,
- error_func *print)
+print_gen_entry_path (line_ref *line, gen_entry *table, error_func *print)
{
if (table->parent == NULL)
{
static void
print_gen_entry_insns (gen_entry *table,
error_func *print,
- char *first_message,
- char *next_message)
+ char *first_message, char *next_message)
{
insn_list *i;
char *message;
{
insn_entry *insn = i->insn;
print_gen_entry_path (insn->line, table, print);
- print (NULL, ": %s.%s %s\n",
- insn->format_name,
- insn->name,
- message);
+ print (NULL, ": %s.%s %s\n", insn->format_name, insn->name, message);
if (next_message != NULL)
message = next_message;
}
{
int bit_nr;
if (l == NULL && r == NULL)
- return 0; /* all previous fields the same */
+ return 0; /* all previous fields the same */
if (l == NULL)
- return -1; /* left shorter than right */
+ return -1; /* left shorter than right */
if (r == NULL)
- return +1; /* left longer than right */
- for (bit_nr = 0;
- bit_nr < options.insn_bit_size;
- bit_nr++)
+ return +1; /* left longer than right */
+ for (bit_nr = 0; bit_nr < options.insn_bit_size; bit_nr++)
{
if (l->bit[bit_nr]->field->type != insn_field_string)
continue;
if (0)
printf ("%s%s%s VS %s%s%s\n",
l->bit[bit_nr]->field->val_string,
- l->bit[bit_nr]->field->conditions->test == insn_field_cond_eq ? "=" : "!",
- l->bit[bit_nr]->field->conditions->string,
+ l->bit[bit_nr]->field->conditions->test ==
+ insn_field_cond_eq ? "=" : "!",
+ l->bit[bit_nr]->field->conditions->string,
r->bit[bit_nr]->field->val_string,
- r->bit[bit_nr]->field->conditions->test == insn_field_cond_eq ? "=" : "!",
+ r->bit[bit_nr]->field->conditions->test ==
+ insn_field_cond_eq ? "=" : "!",
r->bit[bit_nr]->field->conditions->string);
if (l->bit[bit_nr]->field->conditions->test == insn_field_cond_eq
- && r->bit[bit_nr]->field->conditions->test == insn_field_cond_eq)
+ && r->bit[bit_nr]->field->conditions->test ==
+ insn_field_cond_eq)
{
- if (l->bit[bit_nr]->field->conditions->type == insn_field_cond_field
- && r->bit[bit_nr]->field->conditions->type == insn_field_cond_field)
+ if (l->bit[bit_nr]->field->conditions->type ==
+ insn_field_cond_field
+ && r->bit[bit_nr]->field->conditions->type ==
+ insn_field_cond_field)
/* somewhat arbitrary */
{
int cmp = strcmp (l->bit[bit_nr]->field->conditions->string,
- r->bit[bit_nr]->field->conditions->string);
+ r->bit[bit_nr]->field->conditions->
+ string);
if (cmp != 0)
return cmp;
else
continue;
}
- if (l->bit[bit_nr]->field->conditions->type == insn_field_cond_field)
+ if (l->bit[bit_nr]->field->conditions->type ==
+ insn_field_cond_field)
return +1;
- if (r->bit[bit_nr]->field->conditions->type == insn_field_cond_field)
+ if (r->bit[bit_nr]->field->conditions->type ==
+ insn_field_cond_field)
return -1;
/* The case of both fields having constant values should have
- already have been handled because such fields are converted
- into normal constant fields. */
+ already have been handled because such fields are converted
+ into normal constant fields. */
continue;
}
if (l->bit[bit_nr]->field->conditions->test == insn_field_cond_eq)
- return +1; /* left = only */
+ return +1; /* left = only */
if (r->bit[bit_nr]->field->conditions->test == insn_field_cond_eq)
- return -1; /* right = only */
+ return -1; /* right = only */
/* FIXME: Need to some what arbitrarily order conditional lists */
continue;
}
{
int bit_nr;
if (l == NULL && r == NULL)
- return 0; /* all previous fields the same */
+ return 0; /* all previous fields the same */
if (l == NULL)
- return -1; /* left shorter than right */
+ return -1; /* left shorter than right */
if (r == NULL)
- return +1; /* left longer than right */
- for (bit_nr = 0;
- bit_nr < options.insn_bit_size;
- bit_nr++)
+ return +1; /* left longer than right */
+ for (bit_nr = 0; bit_nr < options.insn_bit_size; bit_nr++)
{
if (l->bit[bit_nr]->mask < r->bit[bit_nr]->mask)
return -1;
/* same as strcmp */
static int
-opcode_bit_cmp (opcode_bits *l,
- opcode_bits *r)
+opcode_bit_cmp (opcode_bits *l, opcode_bits *r)
{
if (l == NULL && r == NULL)
- return 0; /* all previous bits the same */
+ return 0; /* all previous bits the same */
if (l == NULL)
- return -1; /* left shorter than right */
+ return -1; /* left shorter than right */
if (r == NULL)
- return +1; /* left longer than right */
+ return +1; /* left longer than right */
/* most significant word */
if (l->field->word_nr < r->field->word_nr)
- return +1; /* left has more significant word */
+ return +1; /* left has more significant word */
if (l->field->word_nr > r->field->word_nr)
- return -1; /* right has more significant word */
+ return -1; /* right has more significant word */
/* most significant bit? */
if (l->first < r->first)
- return +1; /* left as more significant bit */
+ return +1; /* left as more significant bit */
if (l->first > r->first)
- return -1; /* right as more significant bit */
+ return -1; /* right as more significant bit */
/* nr bits? */
if (l->last < r->last)
- return +1; /* left as less bits */
+ return +1; /* left as less bits */
if (l->last > r->last)
- return -1; /* right as less bits */
+ return -1; /* right as less bits */
/* value? */
if (l->value < r->value)
return -1;
/* same as strcmp */
static int
-opcode_bits_cmp (opcode_bits *l,
- opcode_bits *r)
+opcode_bits_cmp (opcode_bits *l, opcode_bits *r)
{
while (1)
{
int cmp;
if (l == NULL && r == NULL)
- return 0; /* all previous bits the same */
+ return 0; /* all previous bits the same */
cmp = opcode_bit_cmp (l, r);
if (cmp != 0)
return cmp;
new_opcode_bits (opcode_bits *old_bits,
int value,
int first,
- int last,
- insn_field_entry *field,
- opcode_field *opcode)
+ int last, insn_field_entry *field, opcode_field *opcode)
{
opcode_bits *new_bits = ZALLOC (opcode_bits);
new_bits->field = field;
new_bits->first = first;
new_bits->last = last;
new_bits->opcode = opcode;
-
+
if (old_bits != NULL)
{
opcode_bits *new_list;
old_bits->value,
old_bits->first,
old_bits->last,
- old_bits->field,
- old_bits->opcode);
+ old_bits->field, old_bits->opcode);
while (*last != NULL)
{
int cmp = opcode_bit_cmp (new_bits, *last);
- if (cmp < 0) /* new < new_list */
+ if (cmp < 0) /* new < new_list */
{
break;
}
}
-typedef enum {
+typedef enum
+{
merge_duplicate_insns,
report_duplicate_insns,
-} duplicate_insn_actions;
+}
+duplicate_insn_actions;
static insn_list *
insn_list_insert (insn_list **cur_insn_ptr,
int *nr_insns,
- insn_entry *insn,
+ insn_entry * insn,
opcode_bits *expanded_bits,
opcode_field *opcodes,
int nr_prefetched_words,
continue;
/* key#4 sort according to the format-name. If two apparently
- identical instructions have unique format-names, then the
- instructions are different. This is because the
- format-name's use is overloaded, it not only indicates the
- format name but also provides a unique semantic name for the
- function. */
- cmp = format_name_cmp (insn->format_name, (*cur_insn_ptr)->insn->format_name);
+ identical instructions have unique format-names, then the
+ instructions are different. This is because the
+ format-name's use is overloaded, it not only indicates the
+ format name but also provides a unique semantic name for the
+ function. */
+ cmp =
+ format_name_cmp (insn->format_name,
+ (*cur_insn_ptr)->insn->format_name);
if (cmp < 0)
break;
else if (cmp > 0)
}
}
-
+
/* create a new list entry and insert it */
{
insn_list *new_insn = ZALLOC (insn_list);
}
(*cur_insn_ptr) = new_insn;
}
-
+
*nr_insns += 1;
return (*cur_insn_ptr);
gen_entry_traverse_tree (lf *file,
gen_entry *table,
int depth,
- gen_entry_handler *start,
- gen_entry_handler *leaf,
- gen_entry_handler *end,
- void *data)
+ gen_entry_handler * start,
+ gen_entry_handler * leaf,
+ gen_entry_handler * end, void *data)
{
gen_entry *entry;
-
- ASSERT (table != NULL);
+
+ ASSERT (table !=NULL);
ASSERT (table->opcode != NULL);
ASSERT (table->nr_entries > 0);
ASSERT (table->entries != 0);
-
+
/* prefix */
if (start != NULL && depth >= 0)
{
start (file, table, depth, data);
}
/* infix leaves */
- for (entry = table->entries;
- entry != NULL;
- entry = entry->sibling)
+ for (entry = table->entries; entry != NULL; entry = entry->sibling)
{
if (entry->entries != NULL && depth != 0)
{
/* create a list element containing a single gen_table entry */
static gen_list *
-make_table (insn_table *isa,
- decode_table *rules,
- model_entry *model)
+make_table (insn_table *isa, decode_table *rules, model_entry *model)
{
insn_entry *insn;
gen_list *entry = ZALLOC (gen_list);
|| insn->processors == NULL
|| filter_is_member (insn->processors, model->name))
{
- insn_list_insert (&entry->table->insns,
- &entry->table->nr_insns,
- insn,
- NULL, /* expanded_bits - none yet */
- NULL, /* opcodes - none yet */
- 0, /* nr_prefetched_words - none yet */
+ insn_list_insert (&entry->table->insns, &entry->table->nr_insns, insn, NULL, /* expanded_bits - none yet */
+ NULL, /* opcodes - none yet */
+ 0, /* nr_prefetched_words - none yet */
report_duplicate_insns);
}
}
gen_table *
-make_gen_tables (insn_table *isa,
- decode_table *rules)
+make_gen_tables (insn_table *isa, decode_table *rules)
{
gen_table *gen = ZALLOC (gen_table);
gen->isa = isa;
processors = options.model_filter;
else
processors = isa->model->processors;
- for (model = isa->model->models;
- model != NULL;
- model = model->next)
+ for (model = isa->model->models; model != NULL; model = model->next)
{
if (filter_is_member (processors, model->name))
{
}
return gen;
}
-
-
+
+
/****************************************************************/
#if 0
-typedef enum {
+typedef enum
+{
field_is_not_constant = 0,
field_constant_int = 1,
field_constant_reserved = 2,
field_constant_string = 3
-} constant_field_types;
+}
+constant_field_types;
static constant_field_types
-insn_field_is_constant (insn_field *field,
- decode_table *rule)
+insn_field_is_constant (insn_field * field, decode_table *rule)
{
switch (field->type)
{
else
return field_is_not_constant;
case insn_field_wild:
- return field_is_not_constant; /* never constant */
+ return field_is_not_constant; /* never constant */
case insn_field_string:
/* field, though variable, is on the list of forced constants */
if (filter_is_member (rule->constant_field_names, field->val_string))
/* Is the bit, according to the decode rule, identical across all the
instructions? */
static int
-insns_bit_useless (insn_list *insns,
- decode_table *rule,
- int bit_nr)
+insns_bit_useless (insn_list *insns, decode_table *rule, int bit_nr)
{
insn_list *entry;
int value = -1;
- int is_useless = 1; /* cleared if something actually found */
+ int is_useless = 1; /* cleared if something actually found */
/* check the instructions for some constant value in at least one of
the bit fields */
case decode_find_constants:
case decode_find_mixed:
/* an integer is useful if its value isn't the same
- between all instructions. The first time through the
- value is saved, the second time through (if the
- values differ) it is marked as useful. */
+ between all instructions. The first time through the
+ value is saved, the second time through (if the
+ values differ) it is marked as useful. */
if (value < 0)
value = bit->value;
else if (value != bit->value)
break;
case decode_find_mixed:
/* string field with conditions. If this condition
- eliminates the value then the compare is useful */
+ eliminates the value then the compare is useful */
if (bit->field->conditions != NULL)
{
insn_field_cond *condition;
int shift = bit->field->last - bit_nr;
for (condition = bit->field->conditions;
- condition != NULL;
- condition = condition->next)
+ condition != NULL; condition = condition->next)
{
switch (condition->type)
{
if (((condition->value >> shift) & 1)
== (unsigned) value)
/* conditional field excludes the
- current value */
+ current value */
is_useless = 0;
break;
case insn_field_cond_eq:
if (((condition->value >> shift) & 1)
!= (unsigned) value)
/* conditional field requires the
- current value */
+ current value */
is_useless = 0;
break;
}
static opcode_field *
gen_entry_find_opcode_field (insn_list *insns,
- decode_table *rule,
- int string_only)
+ decode_table *rule, int string_only)
{
opcode_field curr_opcode;
ASSERT (rule != NULL);
while (curr_opcode.first <= rule->last)
{
if (insns_bit_useless (insns, rule, curr_opcode.first))
- curr_opcode.first ++;
+ curr_opcode.first++;
else
break;
}
while (curr_opcode.last >= rule->first)
{
if (insns_bit_useless (insns, rule, curr_opcode.last))
- curr_opcode.last --;
+ curr_opcode.last--;
else
break;
}
{
insn_word_entry *fields = entry->insn->word[rule->word_nr];
opcode_field new_opcode;
-
+
ASSERT (fields != NULL);
-
+
/* find a start point for the opcode field */
new_opcode.first = rule->first;
while (new_opcode.first <= rule->last
&& (!string_only
- || (insn_field_is_constant(fields->bit[new_opcode.first], rule)
- != field_constant_string))
- && (string_only
- || (insn_field_is_constant(fields->bit[new_opcode.first], rule)
- == field_is_not_constant)))
+ ||
+ (insn_field_is_constant (fields->bit[new_opcode.first], rule)
+ != field_constant_string)) && (string_only
+ ||
+ (insn_field_is_constant
+ (fields->
+ bit[new_opcode.first],
+ rule) ==
+ field_is_not_constant)))
{
int new_first = fields->bit[new_opcode.first]->last + 1;
ASSERT (new_first > new_opcode.first);
new_opcode.first = new_first;
}
- ASSERT(new_opcode.first > rule->last
- || (string_only
- && insn_field_is_constant(fields->bit[new_opcode.first],
- rule) == field_constant_string)
- || (!string_only
- && insn_field_is_constant(fields->bit[new_opcode.first],
- rule)));
-
+ ASSERT (new_opcode.first > rule->last
+ || (string_only
+ && insn_field_is_constant (fields->bit[new_opcode.first],
+ rule) == field_constant_string)
+ || (!string_only
+ && insn_field_is_constant (fields->bit[new_opcode.first],
+ rule)));
+
/* find the end point for the opcode field */
new_opcode.last = rule->last;
while (new_opcode.last >= rule->first
&& (!string_only
- || insn_field_is_constant(fields->bit[new_opcode.last],
- rule) != field_constant_string)
+ || insn_field_is_constant (fields->bit[new_opcode.last],
+ rule) != field_constant_string)
&& (string_only
- || !insn_field_is_constant(fields->bit[new_opcode.last],
- rule)))
+ || !insn_field_is_constant (fields->bit[new_opcode.last],
+ rule)))
{
int new_last = fields->bit[new_opcode.last]->first - 1;
ASSERT (new_last < new_opcode.last);
new_opcode.last = new_last;
}
- ASSERT(new_opcode.last < rule->first
- || (string_only
- && insn_field_is_constant(fields->bit[new_opcode.last],
- rule) == field_constant_string)
- || (!string_only
- && insn_field_is_constant(fields->bit[new_opcode.last],
- rule)));
-
+ ASSERT (new_opcode.last < rule->first
+ || (string_only
+ && insn_field_is_constant (fields->bit[new_opcode.last],
+ rule) == field_constant_string)
+ || (!string_only
+ && insn_field_is_constant (fields->bit[new_opcode.last],
+ rule)));
+
/* now see if our current opcode needs expanding to include the
- interesting fields within this instruction */
+ interesting fields within this instruction */
if (new_opcode.first <= rule->last
&& curr_opcode.first > new_opcode.first)
curr_opcode.first = new_opcode.first;
if (new_opcode.last >= rule->first
&& curr_opcode.last < new_opcode.last)
curr_opcode.last = new_opcode.last;
-
+
}
#endif
/* Ensure that, for the non string only case, the opcode includes
the range forced_first .. forced_last */
- if (!string_only
- && curr_opcode.first > rule->force_first)
+ if (!string_only && curr_opcode.first > rule->force_first)
{
curr_opcode.first = rule->force_first;
}
- if (!string_only
- && curr_opcode.last < rule->force_last)
+ if (!string_only && curr_opcode.last < rule->force_last)
{
curr_opcode.last = rule->force_last;
}
/* For the string only case, force just the lower bound (so that the
shift can be eliminated) */
- if (string_only
- && rule->force_last == options.insn_bit_size - 1)
+ if (string_only && rule->force_last == options.insn_bit_size - 1)
{
curr_opcode.last = options.insn_bit_size - 1;
}
static void
gen_entry_insert_insn (gen_entry *table,
- insn_entry *old_insn,
+ insn_entry * old_insn,
int new_word_nr,
int new_nr_prefetched_words,
- int new_opcode_nr,
- opcode_bits *new_bits)
+ int new_opcode_nr, opcode_bits *new_bits)
{
gen_entry **entry = &table->entries;
-
+
/* find the new table for this entry */
while ((*entry) != NULL && (*entry)->opcode_nr < new_opcode_nr)
{
entry = &(*entry)->sibling;
}
-
+
if ((*entry) == NULL || (*entry)->opcode_nr != new_opcode_nr)
{
/* insert the missing entry */
}
/* ASSERT new_bits == cur_entry bits */
ASSERT ((*entry) != NULL && (*entry)->opcode_nr == new_opcode_nr);
- insn_list_insert (&(*entry)->insns,
- &(*entry)->nr_insns,
- old_insn,
- NULL, /* expanded_bits - only in final list */
- NULL, /* opcodes - only in final list */
- new_nr_prefetched_words, /* for this table */
+ insn_list_insert (&(*entry)->insns, &(*entry)->nr_insns, old_insn, NULL, /* expanded_bits - only in final list */
+ NULL, /* opcodes - only in final list */
+ new_nr_prefetched_words, /* for this table */
report_duplicate_insns);
}
static void
gen_entry_expand_opcode (gen_entry *table,
- insn_entry *instruction,
- int bit_nr,
- int opcode_nr,
- opcode_bits *bits)
+ insn_entry * instruction,
+ int bit_nr, int opcode_nr, opcode_bits *bits)
{
if (bit_nr > table->opcode->last)
{
opcode_nr,
instruction->format_name,
instruction->name,
- (table->opcode_rule->with_duplicates ? " (duplicated)" : ""));
+ (table->opcode_rule->
+ with_duplicates ? " (duplicated)" : ""));
}
if (table->opcode_rule->with_duplicates)
{
gen_entry_insert_insn (table, instruction,
table->opcode->word_nr,
- table->nr_prefetched_words,
- opcode_nr, bits);
+ table->nr_prefetched_words, opcode_nr, bits);
}
else
{
gen_entry_insert_insn (table, instruction,
table->opcode->word_nr,
- table->nr_prefetched_words,
- opcode_nr, NULL);
+ table->nr_prefetched_words, opcode_nr, NULL);
}
}
else
insn_word_entry *word = instruction->word[table->opcode->word_nr];
insn_field_entry *field = word->bit[bit_nr]->field;
int last_pos = ((field->last < table->opcode->last)
- ? field->last
- : table->opcode->last);
+ ? field->last : table->opcode->last);
int first_pos = ((field->first > table->opcode->first)
- ? field->first
- : table->opcode->first);
+ ? field->first : table->opcode->first);
int width = last_pos - first_pos + 1;
switch (field->type)
{
case insn_field_int:
{
int val;
- val = sub_val (field->val_int, field->last,
- first_pos, last_pos);
+ val = sub_val (field->val_int, field->last, first_pos, last_pos);
gen_entry_expand_opcode (table, instruction,
last_pos + 1,
- ((opcode_nr << width) | val),
- bits);
+ ((opcode_nr << width) | val), bits);
break;
}
default:
if (field->type == insn_field_reserved)
gen_entry_expand_opcode (table, instruction,
last_pos + 1,
- ((opcode_nr << width)),
- bits);
+ ((opcode_nr << width)), bits);
else
{
int val;
- int last_val = (table->opcode->is_boolean
- ? 2
- : (1 << width));
+ int last_val = (table->opcode->is_boolean ? 2 : (1 << width));
for (val = 0; val < last_val; val++)
{
/* check to see if the value has been precluded
- (by a conditional) in some way */
+ (by a conditional) in some way */
int is_precluded;
insn_field_cond *condition;
for (condition = field->conditions, is_precluded = 0;
{
case insn_field_cond_value:
{
- int value = sub_val (condition->value, field->last,
- first_pos, last_pos);
+ int value =
+ sub_val (condition->value, field->last,
+ first_pos, last_pos);
switch (condition->test)
{
case insn_field_cond_ne:
opcode_bits *bit;
gen_entry *t = NULL;
/* Try to find a value for the
- conditional by looking back through
- the previously defined bits for one
- that covers the designated
- conditional field */
- for (bit = bits;
- bit != NULL;
- bit = bit->next)
+ conditional by looking back through
+ the previously defined bits for one
+ that covers the designated
+ conditional field */
+ for (bit = bits; bit != NULL; bit = bit->next)
{
- if (bit->field->word_nr == condition->field->word_nr
+ if (bit->field->word_nr ==
+ condition->field->word_nr
&& bit->first <= condition->field->first
&& bit->last >= condition->field->last)
{
/* the bit field fully specified
- the conditional field's value */
+ the conditional field's value */
value = sub_val (bit->value, bit->last,
- condition->field->first,
- condition->field->last);
+ condition->field->
+ first,
+ condition->field->
+ last);
}
}
/* Try to find a value by looking
- through this and previous tables */
+ through this and previous tables */
if (bit == NULL)
{
for (t = table;
- t->parent != NULL;
- t = t->parent)
+ t->parent != NULL; t = t->parent)
{
- if (t->parent->opcode->word_nr == condition->field->word_nr
- && t->parent->opcode->first <= condition->field->first
- && t->parent->opcode->last >= condition->field->last)
+ if (t->parent->opcode->word_nr ==
+ condition->field->word_nr
+ && t->parent->opcode->first <=
+ condition->field->first
+ && t->parent->opcode->last >=
+ condition->field->last)
{
/* the table entry fully
- specified the condition
- field's value */
+ specified the condition
+ field's value */
/* extract the field's value
- from the opcode */
- value = sub_val (t->opcode_nr, t->parent->opcode->last,
- condition->field->first, condition->field->last);
+ from the opcode */
+ value =
+ sub_val (t->opcode_nr,
+ t->parent->opcode->last,
+ condition->field->first,
+ condition->field->last);
/* this is a requirement of
- a conditonal field
- refering to another field */
- ASSERT ((condition->field->first - condition->field->last)
- == (first_pos - last_pos));
-printf ("value=%d, opcode_nr=%d, last=%d, [%d..%d]\n",
- value, t->opcode_nr, t->parent->opcode->last, condition->field->first, condition->field->last);
+ a conditonal field
+ refering to another field */
+ ASSERT ((condition->field->first -
+ condition->field->last) ==
+ (first_pos - last_pos));
+ printf
+ ("value=%d, opcode_nr=%d, last=%d, [%d..%d]\n",
+ value, t->opcode_nr,
+ t->parent->opcode->last,
+ condition->field->first,
+ condition->field->last);
}
}
}
if (!is_precluded)
{
/* Only add additional hardwired bit
- information if the entry is not going to
- later be combined */
+ information if the entry is not going to
+ later be combined */
if (table->opcode_rule->with_combine)
{
gen_entry_expand_opcode (table, instruction,
last_pos + 1,
- ((opcode_nr << width) | val),
- bits);
+ ((opcode_nr << width) |
+ val), bits);
}
else
{
- opcode_bits *new_bits = new_opcode_bits (bits, val,
- first_pos, last_pos,
- field,
- table->opcode);
+ opcode_bits *new_bits =
+ new_opcode_bits (bits, val,
+ first_pos, last_pos,
+ field,
+ table->opcode);
gen_entry_expand_opcode (table, instruction,
last_pos + 1,
- ((opcode_nr << width) | val),
- new_bits);
+ ((opcode_nr << width) |
+ val), new_bits);
}
}
}
}
static void
-gen_entry_insert_expanding (gen_entry *table,
- insn_entry *instruction)
+gen_entry_insert_expanding (gen_entry *table, insn_entry * instruction)
{
gen_entry_expand_opcode (table,
instruction,
- table->opcode->first,
- 0,
- table->expanded_bits);
+ table->opcode->first, 0, table->expanded_bits);
}
static int
-insns_match_format_names (insn_list *insns,
- filter *format_names)
+insns_match_format_names (insn_list *insns, filter *format_names)
{
if (format_names != NULL)
{
insn_list *i;
for (i = insns; i != NULL; i = i->next)
{
- if ( i->insn->format_name != NULL
- && !filter_is_member (format_names, i->insn->format_name))
+ if (i->insn->format_name != NULL
+ && !filter_is_member (format_names, i->insn->format_name))
return 0;
}
}
}
static int
-table_matches_path (gen_entry *table,
- decode_path_list *paths)
+table_matches_path (gen_entry *table, decode_path_list *paths)
{
if (paths == NULL)
return 1;
static int
-insns_match_conditions (insn_list *insns,
- decode_cond *conditions)
+insns_match_conditions (insn_list *insns, decode_cond *conditions)
{
if (conditions != NULL)
{
if (!i->insn->word[cond->word_nr]->bit[bit_nr]->mask)
return 0;
if ((i->insn->word[cond->word_nr]->bit[bit_nr]->value
- == cond->value[bit_nr])
- == !cond->is_equal)
+ == cond->value[bit_nr]) == !cond->is_equal)
return 0;
}
}
}
static int
-insns_match_nr_words (insn_list *insns,
- int nr_words)
+insns_match_nr_words (insn_list *insns, int nr_words)
{
insn_list *i;
for (i = insns; i != NULL; i = i->next)
}
static int
-insn_list_cmp (insn_list *l,
- insn_list *r)
+insn_list_cmp (insn_list *l, insn_list *r)
{
while (1)
{
if (r == NULL)
return 1;
if (l->insn != r->insn)
- return -1; /* somewhat arbitrary at present */
+ return -1; /* somewhat arbitrary at present */
/* skip this insn */
insn = l->insn;
while (l != NULL && l->insn == insn)
{
decode_table *opcode_rule;
- ASSERT(table->nr_insns >= 1);
-
+ ASSERT (table->nr_insns >= 1);
+
/* determine a valid opcode */
for (opcode_rule = table->opcode_rule;
- opcode_rule != NULL;
- opcode_rule = opcode_rule->next)
+ opcode_rule != NULL; opcode_rule = opcode_rule->next)
{
char *discard_reason;
if (table->top->model != NULL
else if (table->nr_insns == 1 && opcode_rule->conditions == NULL)
{
/* for safety, require a pre-codition when attempting to
- apply a rule to a single instruction */
+ apply a rule to a single instruction */
discard_reason = "need pre-condition when nr-insn == 1";
}
else if (table->nr_insns == 1 && !opcode_rule->with_duplicates)
{
/* Little point in expanding a single instruction when we're
- not duplicating the semantic functions that this table
- calls */
+ not duplicating the semantic functions that this table
+ calls */
discard_reason = "need duplication with nr-insns == 1";
}
- else if (!insns_match_format_names (table->insns, opcode_rule->format_names))
+ else
+ if (!insns_match_format_names
+ (table->insns, opcode_rule->format_names))
{
discard_reason = "wrong format name";
}
{
discard_reason = "path failed";
}
- else if (!insns_match_conditions (table->insns, opcode_rule->conditions))
+ else
+ if (!insns_match_conditions (table->insns, opcode_rule->conditions))
{
discard_reason = "condition failed";
}
else
{
discard_reason = "no opcode field";
- table->opcode =
- gen_entry_find_opcode_field (table->insns,
- opcode_rule,
- table->nr_insns == 1/*string-only*/
- );
+ table->opcode = gen_entry_find_opcode_field (table->insns,
+ opcode_rule,
+ table->nr_insns == 1 /*string-only */
+ );
if (table->opcode != NULL)
{
table->opcode_rule = opcode_rule;
notify (NULL, ": rule discarded - %s\n", discard_reason);
}
}
-
+
/* did we find anything */
if (opcode_rule == NULL)
{
this table to function */
if (table->parent == NULL)
table->nr_prefetched_words = table->opcode_rule->word_nr + 1;
- else if (table->opcode_rule->word_nr + 1 > table->parent->nr_prefetched_words)
+ else if (table->opcode_rule->word_nr + 1 >
+ table->parent->nr_prefetched_words)
table->nr_prefetched_words = table->opcode_rule->word_nr + 1;
else
table->nr_prefetched_words = table->parent->nr_prefetched_words;
/* back link what we found to its parent */
if (table->parent != NULL)
{
- ASSERT(table->parent->opcode != NULL);
+ ASSERT (table->parent->opcode != NULL);
table->opcode->parent = table->parent->opcode;
}
i2target (options.hi_bit_nr, table->opcode->last),
i2target (options.hi_bit_nr, table->opcode_rule->first),
i2target (options.hi_bit_nr, table->opcode_rule->last),
- table->opcode->nr_opcodes,
- table->nr_entries);
+ table->opcode->nr_opcodes, table->nr_entries);
}
/* expand the raw instructions according to the opcode */
{
print_gen_entry_path (table->opcode_rule->line, table, notify);
notify (NULL, ": expand - %s.%s\n",
- entry->insn->format_name,
- entry->insn->name);
+ entry->insn->format_name, entry->insn->name);
}
gen_entry_insert_expanding (table, entry->insn);
}
insn_list *l;
print_gen_entry_path (table->opcode_rule->line, entry, notify);
notify (NULL, ": %d - entries %d -",
- entry->opcode_nr,
- entry->nr_insns);
+ entry->opcode_nr, entry->nr_insns);
for (l = entry->insns; l != NULL; l = l->next)
notify (NULL, " %s.%s", l->insn->format_name, l->insn->name);
notify (NULL, "\n");
}
}
-
+
/* perform a combine pass if needed */
if (table->opcode_rule->with_combine)
{
insn_list *l;
gen_entry *duplicate;
nr_unique++;
- print_gen_entry_path (table->opcode_rule->line, entry, notify);
- for (duplicate = entry->combined_next;
- duplicate != NULL;
+ print_gen_entry_path (table->opcode_rule->line, entry,
+ notify);
+ for (duplicate = entry->combined_next; duplicate != NULL;
duplicate = duplicate->combined_next)
{
notify (NULL, "+%d", duplicate->opcode_nr);
for (l = entry->insns; l != NULL; l = l->next)
{
notify (NULL, " %s.%s",
- l->insn->format_name,
- l->insn->name);
+ l->insn->format_name, l->insn->name);
}
notify (NULL, "\n");
}
}
print_gen_entry_path (table->opcode_rule->line, table, notify);
- notify (NULL, ": combine - word %d, bits [%d..%d] in [%d..%d], opcodes %d, entries %d, unique %d\n",
- table->opcode->word_nr,
- i2target (options.hi_bit_nr, table->opcode->first),
+ notify (NULL,
+ ": combine - word %d, bits [%d..%d] in [%d..%d], opcodes %d, entries %d, unique %d\n",
+ table->opcode->word_nr, i2target (options.hi_bit_nr,
+ table->opcode->first),
i2target (options.hi_bit_nr, table->opcode->last),
i2target (options.hi_bit_nr, table->opcode_rule->first),
i2target (options.hi_bit_nr, table->opcode_rule->last),
- table->opcode->nr_opcodes,
- table->nr_entries,
- nr_unique);
+ table->opcode->nr_opcodes, table->nr_entries, nr_unique);
}
}
-
+
/* Check that the rule did more than re-arange the order of the
instructions */
{
- gen_entry *entry;
- for (entry = table->entries; entry != NULL; entry = entry->sibling)
- {
- if (entry->combined_parent == NULL)
- {
- if (insn_list_cmp (table->insns, entry->insns) == 0)
- {
- print_gen_entry_path (table->opcode_rule->line, table, warning);
- warning (NULL, ": Applying rule just copied all instructions\n");
- print_gen_entry_insns (entry, warning, "Copied", NULL);
- error (NULL, "");
- }
- }
- }
+ gen_entry *entry;
+ for (entry = table->entries; entry != NULL; entry = entry->sibling)
+ {
+ if (entry->combined_parent == NULL)
+ {
+ if (insn_list_cmp (table->insns, entry->insns) == 0)
+ {
+ print_gen_entry_path (table->opcode_rule->line, table,
+ warning);
+ warning (NULL,
+ ": Applying rule just copied all instructions\n");
+ print_gen_entry_insns (entry, warning, "Copied", NULL);
+ error (NULL, "");
+ }
+ }
+ }
}
/* if some form of expanded table, fill in the missing dots */
if ((*entry) == NULL || (*entry)->opcode_nr != opcode_nr)
{
/* missing - insert it under our feet at *entry */
- gen_entry_insert_insn (table,
- table->top->isa->illegal_insn,
- table->opcode->word_nr,
- 0, /* nr_prefetched_words == 0 for invalid */
+ gen_entry_insert_insn (table, table->top->isa->illegal_insn, table->opcode->word_nr, 0, /* nr_prefetched_words == 0 for invalid */
opcode_nr, NULL);
ASSERT ((*entry) != NULL);
ASSERT ((*entry)->opcode_nr == opcode_nr);
opcode_nr++;
}
/* oops, will have pointed the first illegal insn back to
- its self. Fix this */
+ its self. Fix this */
if (illegals != NULL)
illegals->combined_parent = NULL;
}
expand entries that haven't been combined. */
{
gen_entry *entry;
- for (entry = table->entries; entry != NULL; entry = entry->sibling)
+ for (entry = table->entries; entry != NULL; entry = entry->sibling)
{
if (entry->combined_parent == NULL)
{
worked. */
static void
-make_gen_semantics_list (lf *file,
- gen_entry *entry,
- int depth,
- void *data)
+make_gen_semantics_list (lf *file, gen_entry *entry, int depth, void *data)
{
- gen_table *gen = (gen_table*) data;
+ gen_table *gen = (gen_table *) data;
insn_list *insn;
/* Not interested in an entrie that have been combined into some
other entry at the same level */
gen_list *entry;
for (entry = gen->tables; entry != NULL; entry = entry->next)
{
- gen_entry_traverse_tree (NULL,
- entry->table,
- 1, /* depth */
- NULL, /* start-handler */
- make_gen_semantics_list, /* leaf-handler */
- NULL, /* end-handler */
- gen); /* data */
- }
+ gen_entry_traverse_tree (NULL, entry->table, 1, /* depth */
+ NULL, /* start-handler */
+ make_gen_semantics_list, /* leaf-handler */
+ NULL, /* end-handler */
+ gen); /* data */
+ }
}
static void
dump_opcode_field (lf *file,
char *prefix,
- opcode_field *field,
- char *suffix,
- int levels)
+ opcode_field *field, char *suffix, int levels)
{
lf_printf (file, "%s(opcode_field *) 0x%lx", prefix, (long) field);
- if (levels && field != NULL) {
- lf_indent (file, +1);
- lf_printf (file, "\n(first %d)", field->first);
- lf_printf (file, "\n(last %d)", field->last);
- lf_printf (file, "\n(nr_opcodes %d)", field->nr_opcodes);
- lf_printf (file, "\n(is_boolean %d)", field->is_boolean);
- lf_printf (file, "\n(boolean_constant %d)", field->boolean_constant);
- dump_opcode_field(file, "\n(parent ", field->parent, ")", levels - 1);
- lf_indent (file, -1);
- }
+ if (levels && field != NULL)
+ {
+ lf_indent (file, +1);
+ lf_printf (file, "\n(first %d)", field->first);
+ lf_printf (file, "\n(last %d)", field->last);
+ lf_printf (file, "\n(nr_opcodes %d)", field->nr_opcodes);
+ lf_printf (file, "\n(is_boolean %d)", field->is_boolean);
+ lf_printf (file, "\n(boolean_constant %d)", field->boolean_constant);
+ dump_opcode_field (file, "\n(parent ", field->parent, ")", levels - 1);
+ lf_indent (file, -1);
+ }
lf_printf (file, "%s", suffix);
}
static void
dump_opcode_bits (lf *file,
- char *prefix,
- opcode_bits *bits,
- char *suffix,
- int levels)
+ char *prefix, opcode_bits *bits, char *suffix, int levels)
{
lf_printf (file, "%s(opcode_bits *) 0x%lx", prefix, (long) bits);
-
+
if (levels && bits != NULL)
{
lf_indent (file, +1);
static void
-dump_insn_list (lf *file,
- char *prefix,
- insn_list *entry,
- char *suffix)
+dump_insn_list (lf *file, char *prefix, insn_list *entry, char *suffix)
{
lf_printf (file, "%s(insn_list *) 0x%lx", prefix, (long) entry);
- if (entry != NULL) {
- lf_indent (file, +1);
- dump_insn_entry (file, "\n(insn ", entry->insn, ")");
- lf_printf (file, "\n(next 0x%lx)", (long) entry->next);
- lf_indent (file, -1);
- }
+ if (entry != NULL)
+ {
+ lf_indent (file, +1);
+ dump_insn_entry (file, "\n(insn ", entry->insn, ")");
+ lf_printf (file, "\n(next 0x%lx)", (long) entry->next);
+ lf_indent (file, -1);
+ }
lf_printf (file, "%s", suffix);
}
static void
dump_insn_word_entry_list_entries (lf *file,
- char *prefix,
- insn_list *entry,
- char *suffix)
+ char *prefix,
+ insn_list *entry, char *suffix)
{
lf_printf (file, "%s", prefix);
while (entry != NULL)
static void
dump_gen_entry (lf *file,
- char *prefix,
- gen_entry *table,
- char *suffix,
- int levels)
+ char *prefix, gen_entry *table, char *suffix, int levels)
{
lf_printf (file, "%s(gen_entry *) 0x%lx", prefix, (long) table);
- if (levels && table != NULL) {
-
- lf_indent (file, +1);
- lf_printf (file, "\n(opcode_nr %d)", table->opcode_nr);
- lf_printf (file, "\n(word_nr %d)", table->word_nr);
- dump_opcode_bits (file, "\n(expanded_bits ", table->expanded_bits, ")", -1);
- lf_printf (file, "\n(nr_insns %d)", table->nr_insns);
- dump_insn_word_entry_list_entries (file, "\n(insns ", table->insns, ")");
- dump_decode_rule (file, "\n(opcode_rule ", table->opcode_rule, ")");
- dump_opcode_field (file, "\n(opcode ", table->opcode, ")", 0);
- lf_printf (file, "\n(nr_entries %d)", table->nr_entries);
- dump_gen_entry (file, "\n(entries ", table->entries, ")", table->nr_entries);
- dump_gen_entry (file, "\n(sibling ", table->sibling, ")", levels - 1);
- dump_gen_entry (file, "\n(parent ", table->parent, ")", 0);
- lf_indent (file, -1);
- }
+ if (levels && table !=NULL)
+ {
+
+ lf_indent (file, +1);
+ lf_printf (file, "\n(opcode_nr %d)", table->opcode_nr);
+ lf_printf (file, "\n(word_nr %d)", table->word_nr);
+ dump_opcode_bits (file, "\n(expanded_bits ", table->expanded_bits, ")",
+ -1);
+ lf_printf (file, "\n(nr_insns %d)", table->nr_insns);
+ dump_insn_word_entry_list_entries (file, "\n(insns ", table->insns,
+ ")");
+ dump_decode_rule (file, "\n(opcode_rule ", table->opcode_rule, ")");
+ dump_opcode_field (file, "\n(opcode ", table->opcode, ")", 0);
+ lf_printf (file, "\n(nr_entries %d)", table->nr_entries);
+ dump_gen_entry (file, "\n(entries ", table->entries, ")",
+ table->nr_entries);
+ dump_gen_entry (file, "\n(sibling ", table->sibling, ")", levels - 1);
+ dump_gen_entry (file, "\n(parent ", table->parent, ")", 0);
+ lf_indent (file, -1);
+ }
lf_printf (file, "%s", suffix);
}
static void
dump_gen_list (lf *file,
- char *prefix,
- gen_list *entry,
- char *suffix,
- int levels)
+ char *prefix, gen_list *entry, char *suffix, int levels)
{
while (entry != NULL)
{
static void
dump_gen_table (lf *file,
- char *prefix,
- gen_table *gen,
- char *suffix,
- int levels)
+ char *prefix, gen_table *gen, char *suffix, int levels)
{
lf_printf (file, "%s(gen_table *) 0x%lx", prefix, (long) gen);
lf_printf (file, "\n(isa (insn_table *) 0x%lx)", (long) gen->isa);
igen_options options;
int
-main (int argc,
- char **argv)
+main (int argc, char **argv)
{
decode_table *decode_rules;
insn_table *instructions;
lf *l;
if (argc != 7)
- error (NULL, "Usage: insn <filter-in> <hi-bit-nr> <insn-bit-size> <widths> <decode-table> <insn-table>\n");
+ error (NULL,
+ "Usage: insn <filter-in> <hi-bit-nr> <insn-bit-size> <widths> <decode-table> <insn-table>\n");
INIT_OPTIONS (options);
filter_parse (&options.flags_filter, argv[1]);
- options.hi_bit_nr = a2i(argv[2]);
- options.insn_bit_size = a2i(argv[3]);
- options.insn_specifying_widths = a2i(argv[4]);
- ASSERT(options.hi_bit_nr < options.insn_bit_size);
+ options.hi_bit_nr = a2i (argv[2]);
+ options.insn_bit_size = a2i (argv[3]);
+ options.insn_specifying_widths = a2i (argv[4]);
+ ASSERT (options.hi_bit_nr < options.insn_bit_size);
instructions = load_insn_table (argv[6], NULL);
decode_rules = load_decode_table (argv[5]);
typedef struct _opcode_field opcode_field;
-struct _opcode_field {
+struct _opcode_field
+{
int word_nr;
int first;
int last;
};
typedef struct _opcode_bits opcode_bits;
-struct _opcode_bits {
+struct _opcode_bits
+{
int value;
int first;
int last;
};
typedef struct _insn_opcodes insn_opcodes;
-struct _insn_opcodes {
+struct _insn_opcodes
+{
opcode_field *opcode;
insn_opcodes *next;
};
typedef struct _insn_list insn_list;
-struct _insn_list {
+struct _insn_list
+{
/* the instruction */
insn_entry *insn;
/* list of non constant bits that have been made constant */
typedef struct _gen_list gen_list;
typedef struct _gen_entry gen_entry;
-struct _gen_entry {
+struct _gen_entry
+{
/* as an entry in a table */
int word_nr;
int opcode_nr;
gen_entry *sibling;
opcode_bits *expanded_bits;
- gen_entry *parent; /* parent has the opcode* data */
+ gen_entry *parent; /* parent has the opcode* data */
/* as a table containing entries */
decode_table *opcode_rule;
};
-struct _gen_list {
+struct _gen_list
+{
model_entry *model;
insn_table *isa;
gen_entry *table;
typedef struct _gen_table gen_table;
-struct _gen_table {
+struct _gen_table
+{
/* list of all the instructions */
insn_table *isa;
/* list of all the semantic functions */
};
-extern gen_table *make_gen_tables
-(insn_table *isa,
- decode_table *rules);
+extern gen_table *make_gen_tables (insn_table *isa, decode_table *rules);
-extern void gen_tables_expand_insns
-(gen_table *gen);
+extern void gen_tables_expand_insns (gen_table *gen);
-extern void gen_tables_expand_semantics
-(gen_table *gen);
+extern void gen_tables_expand_semantics (gen_table *gen);
-extern int gen_entry_depth
-(gen_entry *table);
+extern int gen_entry_depth (gen_entry *table);
/* Traverse the created data structure */
typedef void gen_entry_handler
-(lf *file,
- gen_entry *entry,
- int depth,
- void *data);
+ (lf *file, gen_entry *entry, int depth, void *data);
extern void gen_entry_traverse_tree
-(lf *file,
- gen_entry *table,
- int depth,
- gen_entry_handler *start,
- gen_entry_handler *leaf,
- gen_entry_handler *end,
- void *data);
+ (lf *file,
+ gen_entry *table,
+ int depth,
+ gen_entry_handler * start,
+ gen_entry_handler * leaf, gen_entry_handler * end, void *data);
/* Cache functions: */
-extern int print_icache_function_formal
-(lf *file, int nr_prefetched_words);
+extern int print_icache_function_formal (lf *file, int nr_prefetched_words);
-extern int print_icache_function_actual
-(lf *file, int nr_prefetched_words);
+extern int print_icache_function_actual (lf *file, int nr_prefetched_words);
-extern int print_icache_function_type
-(lf *file);
+extern int print_icache_function_type (lf *file);
-extern int print_semantic_function_formal
-(lf *file, int nr_prefetched_words);
+extern int print_semantic_function_formal (lf *file, int nr_prefetched_words);
-extern int print_semantic_function_actual
-(lf *file, int nr_prefetched_words);
+extern int print_semantic_function_actual (lf *file, int nr_prefetched_words);
-extern int print_semantic_function_type
-(lf *file);
+extern int print_semantic_function_type (lf *file);
-extern int print_idecode_function_formal
-(lf *file, int nr_prefetched_words);
+extern int print_idecode_function_formal (lf *file, int nr_prefetched_words);
-extern int print_idecode_function_actual
-(lf *file, int nr_prefetched_words);
+extern int print_idecode_function_actual (lf *file, int nr_prefetched_words);
-typedef enum {
+typedef enum
+{
function_name_prefix_semantics,
function_name_prefix_idecode,
function_name_prefix_itable,
function_name_prefix_icache,
function_name_prefix_engine,
function_name_prefix_none
-} lf_function_name_prefixes;
+}
+lf_function_name_prefixes;
-typedef enum {
+typedef enum
+{
is_function_declaration = 0,
is_function_definition = 1,
is_function_variable,
-} function_decl_type;
+}
+function_decl_type;
extern int print_function_name
-(lf *file,
- const char *basename,
- const char *format_name,
- const char *model_name,
- opcode_bits *expanded_bits,
- lf_function_name_prefixes prefix);
+ (lf *file,
+ const char *basename,
+ const char *format_name,
+ const char *model_name,
+ opcode_bits *expanded_bits, lf_function_name_prefixes prefix);
extern void print_my_defines
-(lf *file,
- const char *basename,
- const char *format_name,
- opcode_bits *expanded_bits);
+ (lf *file,
+ const char *basename, const char *format_name, opcode_bits *expanded_bits);
-extern void print_itrace
-(lf *file,
- insn_entry *insn,
- int idecode);
+extern void print_itrace (lf *file, insn_entry * insn, int idecode);
-extern void print_sim_engine_abort
-(lf *file,
- const char *message);
+extern void print_sim_engine_abort (lf *file, const char *message);
extern void print_include (lf *file, igen_module module);
-extern void print_include_inline (lf *file, igen_module module);
+extern void print_include_inline (lf *file, igen_module module);
extern void print_includes (lf *file);
-
/* Semantic functions */
int
-print_semantic_function_formal (lf *file,
- int nr_prefetched_words)
+print_semantic_function_formal (lf *file, int nr_prefetched_words)
{
int nr = 0;
int word_nr;
for (word_nr = 0; word_nr < nr_prefetched_words; word_nr++)
{
nr += lf_printf (file, "%sinstruction_word instruction_%d,\n",
- options.module.global.prefix.l,
- word_nr);
+ options.module.global.prefix.l, word_nr);
}
nr += lf_printf (file, "%sinstruction_address cia",
options.module.global.prefix.l);
for (word_nr = 0; word_nr < nr_prefetched_words; word_nr++)
{
nr += lf_printf (file, "%sinstruction_word instruction_%d,\n",
- options.module.global.prefix.l,
- word_nr);
+ options.module.global.prefix.l, word_nr);
}
nr += lf_printf (file, "%sinstruction_address cia",
options.module.global.prefix.l);
}
int
-print_semantic_function_actual (lf *file,
- int nr_prefetched_words)
+print_semantic_function_actual (lf *file, int nr_prefetched_words)
{
int nr = 0;
int word_nr;
/* Idecode functions */
int
-print_icache_function_formal (lf *file,
- int nr_prefetched_words)
+print_icache_function_formal (lf *file, int nr_prefetched_words)
{
int nr = 0;
int word_nr;
if (options.gen.smp)
- nr += lf_printf (file, "sim_cpu *cpu,\n");
+ nr += lf_printf (file, "sim_cpu *cpu,\n");
else
- nr += lf_printf (file, "SIM_DESC sd,\n");
+ nr += lf_printf (file, "SIM_DESC sd,\n");
for (word_nr = 0; word_nr < nr_prefetched_words; word_nr++)
nr += lf_printf (file, " %sinstruction_word instruction_%d,\n",
options.module.global.prefix.l, word_nr);
}
int
-print_icache_function_actual (lf *file,
- int nr_prefetched_words)
+print_icache_function_actual (lf *file, int nr_prefetched_words)
{
int nr = 0;
int word_nr;
/* Function names */
static int
-print_opcode_bits (lf *file,
- opcode_bits *bits)
+print_opcode_bits (lf *file, opcode_bits *bits)
{
int nr = 0;
if (bits == NULL)
nr += lf_putstr (file, bits->field->val_string);
if (bits->opcode->is_boolean && bits->value == 0)
nr += lf_putint (file, bits->opcode->boolean_constant);
- else if (!bits->opcode->is_boolean) {
- if (bits->opcode->last < bits->field->last)
- nr += lf_putint (file, bits->value << (bits->field->last - bits->opcode->last));
- else
- nr += lf_putint (file, bits->value);
- }
+ else if (!bits->opcode->is_boolean)
+ {
+ if (bits->opcode->last < bits->field->last)
+ nr +=
+ lf_putint (file,
+ bits->value << (bits->field->last - bits->opcode->last));
+ else
+ nr += lf_putint (file, bits->value);
+ }
nr += print_opcode_bits (file, bits->next);
return nr;
}
static int
-print_c_name (lf *file,
- const char *name)
+print_c_name (lf *file, const char *name)
{
int nr = 0;
const char *pos;
default:
break;
}
-
+
if (model_name != NULL)
{
nr += print_c_name (file, model_name);
/* the function name */
nr += print_c_name (file, basename);
-
+
/* the format name if available */
if (format_name != NULL)
{
void
print_my_defines (lf *file,
const char *basename,
- const char *format_name,
- opcode_bits *expanded_bits)
+ const char *format_name, opcode_bits *expanded_bits)
{
/* #define MY_INDEX xxxxx */
lf_indent_suppress (file);
lf_printf (file, "#define MY_INDEX ");
print_function_name (file,
basename, format_name, NULL,
- NULL,
- function_name_prefix_itable);
+ NULL, function_name_prefix_itable);
lf_printf (file, "\n");
/* #define MY_PREFIX xxxxxx */
lf_indent_suppress (file);
lf_printf (file, "#undef ");
print_function_name (file,
basename, format_name, NULL,
- expanded_bits,
- function_name_prefix_none);
+ expanded_bits, function_name_prefix_none);
lf_printf (file, "\n");
lf_indent_suppress (file);
lf_printf (file, "#undef MY_PREFIX\n");
lf_printf (file, "#define MY_PREFIX ");
print_function_name (file,
basename, format_name, NULL,
- expanded_bits,
- function_name_prefix_none);
+ expanded_bits, function_name_prefix_none);
lf_printf (file, "\n");
/* #define MY_NAME xxxxxx */
lf_indent_suppress (file);
lf_printf (file, "#define MY_NAME \"");
print_function_name (file,
basename, format_name, NULL,
- expanded_bits,
- function_name_prefix_none);
+ expanded_bits, function_name_prefix_none);
lf_printf (file, "\"\n");
}
{
const char *prefix = "trace_prefix (";
int indent = strlen (prefix);
- lf_printf (file, "%sSD, CPU, cia, CIA, TRACE_LINENUM_P (CPU), \\\n", prefix);
+ lf_printf (file, "%sSD, CPU, cia, CIA, TRACE_LINENUM_P (CPU), \\\n",
+ prefix);
lf_indent (file, +indent);
- lf_printf (file, "%sitable[MY_INDEX].file, \\\n", options.module.itable.prefix.l);
- lf_printf (file, "%sitable[MY_INDEX].line_nr, \\\n", options.module.itable.prefix.l);
+ lf_printf (file, "%sitable[MY_INDEX].file, \\\n",
+ options.module.itable.prefix.l);
+ lf_printf (file, "%sitable[MY_INDEX].line_nr, \\\n",
+ options.module.itable.prefix.l);
lf_printf (file, "\"");
return indent;
}
static void
-print_itrace_format (lf *file,
- insn_mnemonic_entry *assembler)
+print_itrace_format (lf *file, insn_mnemonic_entry *assembler)
{
/* pass=1 is fmt string; pass=2 is arguments */
int pass;
for (pass = 1; pass <= 2; pass++)
{
const char *chp = assembler->format;
- chp++; /* skip the leading quote */
+ chp++; /* skip the leading quote */
/* write out the format/args */
while (*chp != '\0')
{
}
strlen_param = chp - param;
if (chp[0] != '>')
- error (assembler->line, "Missing closing `>' in assembler string\n");
+ error (assembler->line,
+ "Missing closing `>' in assembler string\n");
chp++;
/* now process it */
if (pass == 2)
lf_printf (file, "%%s");
else
{
- lf_printf (file, "%sstr_", options.module.global.prefix.l);
+ lf_printf (file, "%sstr_",
+ options.module.global.prefix.l);
lf_write (file, func, strlen_func);
lf_printf (file, " (SD_, ");
lf_write (file, param, strlen_param);
}
}
else if (strncmp (fmt, "%#lx<", 5) == 0)
- /* simple hex with 0x prefix*/
+ /* simple hex with 0x prefix */
{
if (pass == 1)
lf_printf (file, "%%#lx");
void
-print_itrace (lf *file,
- insn_entry *insn,
- int idecode)
+print_itrace (lf *file, insn_entry * insn, int idecode)
{
/* NB: Here we escape each EOLN. This is so that the the compiler
treats a trace function call as a single line. Consequently any
{
int indent;
lf_printf (file, "%sif (%s)\n",
- is_first ? "" : "else ",
- assembler->condition);
+ is_first ? "" : "else ", assembler->condition);
lf_indent (file, +2);
lf_print__line_ref (file, assembler->line);
indent = print_itrace_prefix (file);
lf_indent (file, -indent);
lf_indent (file, -2);
if (assembler->next == NULL)
- error (assembler->line, "Missing final unconditional assembler\n");
+ error (assembler->line,
+ "Missing final unconditional assembler\n");
}
else
{
if (!is_first)
lf_indent (file, -2);
if (assembler->next != NULL)
- error (assembler->line, "Unconditional assembler is not last\n");
+ error (assembler->line,
+ "Unconditional assembler is not last\n");
}
is_first = 0;
assembler = assembler->next;
}
lf_printf (file, "/* trace the instruction execution if enabled */\n");
lf_printf (file, "if (TRACE_%s_P (CPU))\n", phase);
- lf_printf (file, " trace_generic (SD, CPU, TRACE_%s_IDX, \" %%s\", itable[MY_INDEX].name);\n", phase);
+ lf_printf (file,
+ " trace_generic (SD, CPU, TRACE_%s_IDX, \" %%s\", itable[MY_INDEX].name);\n",
+ phase);
}
lf_indent (file, -4);
lf_printf (file, " }\n");
void
-print_sim_engine_abort (lf *file,
- const char *message)
+print_sim_engine_abort (lf *file, const char *message)
{
lf_printf (file, "sim_engine_abort (SD, CPU, cia, ");
lf_printf (file, "\"%s\"", message);
void
-print_include (lf *file,
- igen_module module)
+print_include (lf *file, igen_module module)
{
lf_printf (file, "#include \"%s%s.h\"\n", module.prefix.l, module.suffix.l);
}
void
-print_include_inline (lf *file,
- igen_module module)
+print_include_inline (lf *file, igen_module module)
{
lf_printf (file, "#if C_REVEALS_MODULE_P (%s_INLINE)\n", module.suffix.u);
lf_printf (file, "#include \"%s%s.c\"\n", module.prefix.l, module.suffix.l);
static void
-gen_semantics_h (lf *file,
- insn_list *semantics,
- int max_nr_words)
+gen_semantics_h (lf *file, insn_list *semantics, int max_nr_words)
{
int word_nr;
insn_list *semantic;
{
lf_printf (file, "typedef ");
print_semantic_function_type (file);
- lf_printf (file, " %sidecode_semantic",
- options.module.global.prefix.l);
+ lf_printf (file, " %sidecode_semantic", options.module.global.prefix.l);
if (word_nr >= 0)
lf_printf (file, "_%d", word_nr);
lf_printf (file, "\n(");
static void
-gen_semantics_c (lf *file,
- insn_list *semantics,
- cache_entry *cache_rules)
+gen_semantics_c (lf *file, insn_list *semantics, cache_entry *cache_rules)
{
if (options.gen.code == generate_calls)
{
static void
gen_icache_h (lf *file,
insn_list *semantic,
- function_entry *functions,
- int max_nr_words)
+ function_entry * functions, int max_nr_words)
{
int word_nr;
for (word_nr = 0; word_nr <= max_nr_words; word_nr++)
{
lf_printf (file, "typedef ");
- print_icache_function_type(file);
+ print_icache_function_type (file);
lf_printf (file, " %sidecode_icache_%d\n(",
- options.module.global.prefix.l,
- word_nr);
- print_icache_function_formal(file, word_nr);
+ options.module.global.prefix.l, word_nr);
+ print_icache_function_formal (file, word_nr);
lf_printf (file, ");\n");
lf_printf (file, "\n");
}
- if (options.gen.code == generate_calls
- && options.gen.icache)
+ if (options.gen.code == generate_calls && options.gen.icache)
{
function_entry_traverse (file, functions,
print_icache_internal_function_declaration,
static void
gen_icache_c (lf *file,
insn_list *semantic,
- function_entry *functions,
- cache_entry *cache_rules)
+ function_entry * functions, cache_entry *cache_rules)
{
/* output `internal' invalid/floating-point unavailable functions
where needed */
- if (options.gen.code == generate_calls
- && options.gen.icache)
+ if (options.gen.code == generate_calls && options.gen.icache)
{
lf_printf (file, "\n");
lf_printf (file, "#include \"cpu.h\"\n");
static void
gen_idecode_h (lf *file,
- gen_table *gen,
- insn_table *insns,
- cache_entry *cache_rules)
+ gen_table *gen, insn_table *insns, cache_entry *cache_rules)
{
lf_printf (file, "typedef unsigned%d %sinstruction_word;\n",
options.insn_bit_size, options.module.global.prefix.l);
options.module.global.prefix.l);
lf_printf (file, " address_word ip; /* instruction pointer */\n");
lf_printf (file, " address_word dp; /* delayed-slot pointer */\n");
- lf_printf (file, "} %sinstruction_address;\n", options.module.global.prefix.l);
+ lf_printf (file, "} %sinstruction_address;\n",
+ options.module.global.prefix.l);
}
else
{
lf_printf (file, "typedef address_word %sinstruction_address;\n",
options.module.global.prefix.l);
-
+
}
if (options.gen.nia == nia_is_invalid
&& strlen (options.module.global.prefix.u) > 0)
? entry->model->name
: NULL),
is_function_declaration,
- 1/*ALWAYS ONE WORD*/);
+ 1 /*ALWAYS ONE WORD */ );
}
if (options.gen.multi_sim)
{
print_idecode_issue_function_header (file,
NULL,
is_function_variable,
- 1/*ALWAYS ONE WORD*/);
+ 1 /*ALWAYS ONE WORD */ );
}
}
}
static void
gen_idecode_c (lf *file,
- gen_table *gen,
- insn_table *isa,
- cache_entry *cache_rules)
+ gen_table *gen, insn_table *isa, cache_entry *cache_rules)
{
/* the intro */
print_includes (file);
print_idecode_globals (file);
lf_printf (file, "\n");
-
+
switch (options.gen.code)
{
case generate_calls:
for (entry = gen->tables; entry != NULL; entry = entry->next)
{
print_idecode_lookups (file, entry->table, cache_rules);
-
+
/* output the main idecode routine */
if (!options.gen.icache)
{
(options.gen.multi_sim
? entry->model->name
: NULL),
- 1/*is definition*/,
- 1/*ALWAYS ONE WORD*/);
+ 1 /*is definition */ ,
+ 1 /*ALWAYS ONE WORD */ );
lf_printf (file, "{\n");
lf_indent (file, +2);
lf_printf (file, "%sinstruction_address nia;\n",
static void
-gen_run_c (lf *file,
- gen_table *gen)
+gen_run_c (lf *file, gen_table *gen)
{
gen_list *entry;
lf_printf (file, "#include \"sim-main.h\"\n");
if (options.gen.multi_sim)
{
- print_idecode_issue_function_header (file, NULL, is_function_variable, 1);
+ print_idecode_issue_function_header (file, NULL, is_function_variable,
+ 1);
lf_printf (file, "\n");
print_engine_run_function_header (file, NULL, is_function_variable);
lf_printf (file, "\n");
}
-
+
lf_printf (file, "void\n");
lf_printf (file, "sim_engine_run (SIM_DESC sd,\n");
lf_printf (file, " int next_cpu_nr,\n");
{
if (options.gen.default_model != NULL
&& (strcmp (entry->model->name, options.gen.default_model) == 0
- || strcmp (entry->model->full_name, options.gen.default_model) == 0))
+ || strcmp (entry->model->full_name,
+ options.gen.default_model) == 0))
lf_printf (file, "default:\n");
lf_printf (file, "case bfd_mach_%s:\n", entry->model->full_name);
lf_indent (file, +2);
- print_function_name (file,
- "issue",
- NULL, /* format name */
- NULL, /* NO processor */
- NULL, /* expanded bits */
+ print_function_name (file, "issue", NULL, /* format name */
+ NULL, /* NO processor */
+ NULL, /* expanded bits */
function_name_prefix_idecode);
lf_printf (file, " = ");
- print_function_name (file,
- "issue",
- NULL, /* format name */
- entry->model->name,
- NULL, /* expanded bits */
+ print_function_name (file, "issue", NULL, /* format name */
+ entry->model->name, NULL, /* expanded bits */
function_name_prefix_idecode);
lf_printf (file, ";\n");
- print_function_name (file,
- "run",
- NULL, /* format name */
- NULL, /* NO processor */
- NULL, /* expanded bits */
+ print_function_name (file, "run", NULL, /* format name */
+ NULL, /* NO processor */
+ NULL, /* expanded bits */
function_name_prefix_engine);
lf_printf (file, " = ");
- print_function_name (file,
- "run",
- NULL, /* format name */
- entry->model->name,
- NULL, /* expanded bits */
+ print_function_name (file, "run", NULL, /* format name */
+ entry->model->name, NULL, /* expanded bits */
function_name_prefix_engine);
lf_printf (file, ";\n");
lf_printf (file, "break;\n");
lf_printf (file, "default:\n");
lf_indent (file, +2);
lf_printf (file, "sim_engine_abort (sd, NULL, NULL_CIA,\n");
- lf_printf (file, " \"sim_engine_run - unknown machine\");\n");
+ lf_printf (file,
+ " \"sim_engine_run - unknown machine\");\n");
lf_printf (file, "break;\n");
lf_indent (file, -2);
}
lf_indent (file, -2);
lf_printf (file, " }\n");
}
- print_function_name (file,
- "run",
- NULL, /* format name */
- NULL, /* NO processor */
- NULL, /* expanded bits */
+ print_function_name (file, "run", NULL, /* format name */
+ NULL, /* NO processor */
+ NULL, /* expanded bits */
function_name_prefix_engine);
lf_printf (file, " (sd, next_cpu_nr, nr_cpus, siggnal);\n");
lf_indent (file, -2);
/****************************************************************/
static gen_table *
-do_gen (insn_table *isa,
- decode_table *decode_rules)
+do_gen (insn_table *isa, decode_table *decode_rules)
{
gen_table *gen;
if (decode_rules == NULL)
igen_options options;
int
-main (int argc,
- char **argv,
- char **envp)
+main (int argc, char **argv, char **envp)
{
cache_entry *cache_rules = NULL;
lf_file_references file_references = lf_include_references;
char *real_file_name = NULL;
int is_header = 0;
int ch;
- lf *standard_out = lf_open ("-", "stdout", lf_omit_references, lf_is_text, "igen");
+ lf *standard_out =
+ lf_open ("-", "stdout", lf_omit_references, lf_is_text, "igen");
INIT_OPTIONS ();
printf ("\n");
printf (" -B <bit-size>\n");
printf ("\t Set the number of bits in an instruction (deprecated).\n");
- printf ("\t This option can now be set directly in the instruction table.\n");
+ printf
+ ("\t This option can now be set directly in the instruction table.\n");
printf ("\n");
printf (" -D <data-structure>\n");
- printf ("\t Dump the specified data structure to stdout. Valid structures include:\n");
- printf ("\t processor-names - list the names of all the processors (models)\n");
+ printf
+ ("\t Dump the specified data structure to stdout. Valid structures include:\n");
+ printf
+ ("\t processor-names - list the names of all the processors (models)\n");
printf ("\n");
printf (" -F <filter-list>\n");
- printf ("\t Filter out any instructions with a non-empty flags field that contains\n");
+ printf
+ ("\t Filter out any instructions with a non-empty flags field that contains\n");
printf ("\t a flag not listed in the <filter-list>.\n");
printf ("\n");
printf (" -H <high-bit>\n");
- printf ("\t Set the number of the high (most significant) instruction bit (deprecated).\n");
- printf ("\t This option can now be set directly in the instruction table.\n");
+ printf
+ ("\t Set the number of the high (most significant) instruction bit (deprecated).\n");
+ printf
+ ("\t This option can now be set directly in the instruction table.\n");
printf ("\n");
printf (" -I <directory>\n");
- printf ("\t Add <directory> to the list of directories searched when opening a file\n");
+ printf
+ ("\t Add <directory> to the list of directories searched when opening a file\n");
printf ("\n");
printf (" -M <model-list>\n");
- printf ("\t Filter out any instructions that do not support at least one of the listed\n");
- printf ("\t models (An instructions with no model information is considered to support\n");
+ printf
+ ("\t Filter out any instructions that do not support at least one of the listed\n");
+ printf
+ ("\t models (An instructions with no model information is considered to support\n");
printf ("\t all models.).\n");
printf ("\n");
printf (" -N <nr-cpus>\n");
printf ("\t Generate a simulator supporting <nr-cpus>\n");
- printf ("\t Specify `-N 0' to disable generation of the SMP. Specifying `-N 1' will\n");
- printf ("\t still generate an SMP enabled simulator but will only support one CPU.\n");
+ printf
+ ("\t Specify `-N 0' to disable generation of the SMP. Specifying `-N 1' will\n");
+ printf
+ ("\t still generate an SMP enabled simulator but will only support one CPU.\n");
printf ("\n");
printf (" -T <mechanism>\n");
- printf ("\t Override the decode mechanism specified by the decode rules\n");
+ printf
+ ("\t Override the decode mechanism specified by the decode rules\n");
printf ("\n");
printf (" -P <prefix>\n");
- printf ("\t Prepend global names (except itable) with the string <prefix>.\n");
- printf ("\t Specify -P <module>=<prefix> to set a specific <module>'s prefix.\n");
+ printf
+ ("\t Prepend global names (except itable) with the string <prefix>.\n");
+ printf
+ ("\t Specify -P <module>=<prefix> to set a specific <module>'s prefix.\n");
printf ("\n");
printf (" -S <suffix>\n");
- printf ("\t Replace a global name (suffix) (except itable) with the string <suffix>.\n");
- printf ("\t Specify -S <module>=<suffix> to change a specific <module>'s name (suffix).\n");
+ printf
+ ("\t Replace a global name (suffix) (except itable) with the string <suffix>.\n");
+ printf
+ ("\t Specify -S <module>=<suffix> to change a specific <module>'s name (suffix).\n");
printf ("\n");
printf (" -Werror\n");
printf ("\t Make warnings errors\n");
printf (" -Wnodiscard\n");
- printf ("\t Suppress warnings about discarded functions and instructions\n");
+ printf
+ ("\t Suppress warnings about discarded functions and instructions\n");
printf (" -Wnowidth\n");
- printf ("\t Suppress warnings about instructions with invalid widths\n");
+ printf
+ ("\t Suppress warnings about instructions with invalid widths\n");
printf (" -Wnounimplemented\n");
printf ("\t Suppress warnings about unimplemented instructions\n");
printf ("\n");
printf (" -G [!]<gen-option>\n");
printf ("\t Any of the following options:\n");
printf ("\n");
- printf ("\t decode-duplicate - Override the decode rules, forcing the duplication of\n");
+ printf
+ ("\t decode-duplicate - Override the decode rules, forcing the duplication of\n");
printf ("\t semantic functions\n");
- printf ("\t decode-combine - Combine any duplicated entries within a table\n");
- printf ("\t decode-zero-reserved - Override the decode rules, forcing reserved bits to be\n");
+ printf
+ ("\t decode-combine - Combine any duplicated entries within a table\n");
+ printf
+ ("\t decode-zero-reserved - Override the decode rules, forcing reserved bits to be\n");
printf ("\t treated as zero.\n");
- printf ("\t decode-switch-is-goto - Overfide the padded-switch code type as a goto-switch\n");
+ printf
+ ("\t decode-switch-is-goto - Overfide the padded-switch code type as a goto-switch\n");
printf ("\n");
- printf ("\t gen-conditional-issue - conditionally issue each instruction\n");
- printf ("\t gen-delayed-branch - need both cia and nia passed around\n");
- printf ("\t gen-direct-access - use #defines to directly access values\n");
- printf ("\t gen-zero-r<N> - arch assumes GPR(<N>) == 0, keep it that way\n");
- printf ("\t gen-icache[=<N> - generate an instruction cracking cache of size <N>\n");
- printf ("\t Default size is %d\n", options.gen.icache_size);
- printf ("\t gen-insn-in-icache - save original instruction when cracking\n");
- printf ("\t gen-multi-sim[=MODEL] - generate multiple simulators - one per model\n");
- printf ("\t If specified MODEL is made the default architecture.\n");
- printf ("\t By default, a single simulator that will\n");
- printf ("\t execute any instruction is generated\n");
- printf ("\t gen-multi-word - generate code allowing for multi-word insns\n");
- printf ("\t gen-semantic-icache - include semantic code in cracking functions\n");
- printf ("\t gen-slot-verification - perform slot verification as part of decode\n");
+ printf
+ ("\t gen-conditional-issue - conditionally issue each instruction\n");
+ printf
+ ("\t gen-delayed-branch - need both cia and nia passed around\n");
+ printf
+ ("\t gen-direct-access - use #defines to directly access values\n");
+ printf
+ ("\t gen-zero-r<N> - arch assumes GPR(<N>) == 0, keep it that way\n");
+ printf
+ ("\t gen-icache[=<N> - generate an instruction cracking cache of size <N>\n");
+ printf ("\t Default size is %d\n",
+ options.gen.icache_size);
+ printf
+ ("\t gen-insn-in-icache - save original instruction when cracking\n");
+ printf
+ ("\t gen-multi-sim[=MODEL] - generate multiple simulators - one per model\n");
+ printf
+ ("\t If specified MODEL is made the default architecture.\n");
+ printf
+ ("\t By default, a single simulator that will\n");
+ printf
+ ("\t execute any instruction is generated\n");
+ printf
+ ("\t gen-multi-word - generate code allowing for multi-word insns\n");
+ printf
+ ("\t gen-semantic-icache - include semantic code in cracking functions\n");
+ printf
+ ("\t gen-slot-verification - perform slot verification as part of decode\n");
printf ("\t gen-nia-invalid - NIA defaults to nia_invalid\n");
printf ("\t gen-nia-void - do not compute/return NIA\n");
printf ("\n");
- printf ("\t trace-combine - report combined entries a rule application\n");
- printf ("\t trace-entries - report entries after a rules application\n");
+ printf
+ ("\t trace-combine - report combined entries a rule application\n");
+ printf
+ ("\t trace-entries - report entries after a rules application\n");
printf ("\t trace-rule-rejection - report each rule as rejected\n");
printf ("\t trace-rule-selection - report each rule as selected\n");
- printf ("\t trace-insn-insertion - report each instruction as it is inserted into a decode table\n");
- printf ("\t trace-rule-expansion - report each instruction as it is expanded (before insertion into a decode table)\n");
+ printf
+ ("\t trace-insn-insertion - report each instruction as it is inserted into a decode table\n");
+ printf
+ ("\t trace-rule-expansion - report each instruction as it is expanded (before insertion into a decode table)\n");
printf ("\t trace-all - enable all trace options\n");
printf ("\n");
- printf ("\t field-widths - instruction formats specify widths (deprecated)\n");
- printf ("\t By default, an instruction format specifies bit\n");
+ printf
+ ("\t field-widths - instruction formats specify widths (deprecated)\n");
+ printf
+ ("\t By default, an instruction format specifies bit\n");
printf ("\t positions\n");
- printf ("\t This option can now be set directly in the\n");
+ printf
+ ("\t This option can now be set directly in the\n");
printf ("\t instruction table\n");
- printf ("\t jumps - use jumps instead of function calls\n");
- printf ("\t omit-line-numbers - do not include line number information in the output\n");
+ printf
+ ("\t jumps - use jumps instead of function calls\n");
+ printf
+ ("\t omit-line-numbers - do not include line number information in the output\n");
printf ("\n");
printf ("Input options:\n");
printf ("\n");
printf ("Output options:\n");
printf ("\n");
printf (" -x Perform expansion (required)\n");
- printf (" -n <real-name> Specify the real name of the next output file\n");
- printf (" -h Generate the header (.h) file rather than the body (.c)\n");
+ printf
+ (" -n <real-name> Specify the real name of the next output file\n");
+ printf
+ (" -h Generate the header (.h) file rather than the body (.c)\n");
printf (" -c <output-file> output icache\n");
printf (" -d <output-file> output idecode\n");
printf (" -e <output-file> output engine\n");
printf (" -s <output-file> output schematic\n");
printf (" -t <output-file> output itable\n");
}
-
- while ((ch = getopt(argc, argv,
- "B:D:F:G:H:I:M:N:P:T:W:o:k:i:n:hc:d:e:m:r:s:t:f:x"))
+
+ while ((ch = getopt (argc, argv,
+ "B:D:F:G:H:I:M:N:P:T:W:o:k:i:n:hc:d:e:m:r:s:t:f:x"))
!= -1)
{
fprintf (stderr, " -%c ", ch);
if (optarg)
fprintf (stderr, "%s ", optarg);
fprintf (stderr, "\\\n");
-
- switch(ch)
+
+ switch (ch)
{
-
+
case 'M':
filter_parse (&options.model_filter, optarg);
break;
case 'F':
filter_parse (&options.flags_filter, optarg);
break;
-
+
case 'I':
{
table_include **dir = &options.include;
(*dir)->dir = strdup (optarg);
}
break;
-
+
case 'B':
options.insn_bit_size = a2i (optarg);
if (options.insn_bit_size <= 0
error (NULL, "Conflict betweem hi-bit-nr and insn-bit-size\n");
}
break;
-
+
case 'H':
options.hi_bit_nr = a2i (optarg);
if (options.hi_bit_nr != options.insn_bit_size - 1
error (NULL, "Conflict between hi-bit-nr and insn-bit-size\n");
}
break;
-
+
case 'N':
options.gen.smp = a2i (optarg);
break;
-
+
case 'P':
case 'S':
{
}
else
{
- chp = chp + 1; /* skip `=' */
+ chp = chp + 1; /* skip `=' */
names = NULL;
if (strncmp (optarg, "global=", chp - optarg) == 0)
{
name = &names->suffix;
break;
default:
- abort (); /* Bad switch. */
+ abort (); /* Bad switch. */
}
name->u = strdup (chp);
name->l = strdup (chp);
chp = name->u;
- while (*chp) {
- if (islower(*chp))
- *chp = toupper(*chp);
- chp++;
- }
+ while (*chp)
+ {
+ if (islower (*chp))
+ *chp = toupper (*chp);
+ chp++;
+ }
if (name == &options.module.global.prefix)
{
options.module.engine.prefix = options.module.global.prefix;
options.module.icache.prefix = options.module.global.prefix;
options.module.idecode.prefix = options.module.global.prefix;
/* options.module.itable.prefix = options.module.global.prefix; */
- options.module.semantics.prefix = options.module.global.prefix;
+ options.module.semantics.prefix =
+ options.module.global.prefix;
options.module.support.prefix = options.module.global.prefix;
}
if (name == &options.module.global.suffix)
options.module.icache.suffix = options.module.global.suffix;
options.module.idecode.suffix = options.module.global.suffix;
/* options.module.itable.suffix = options.module.global.suffix; */
- options.module.semantics.suffix = options.module.global.suffix;
+ options.module.semantics.suffix =
+ options.module.global.suffix;
options.module.support.suffix = options.module.global.suffix;
}
break;
}
-
+
case 'W':
{
if (strcmp (optarg, "error") == 0)
{
options.decode.zero_reserved = enable_p;
}
-
+
else if (strcmp (argp, "gen-conditional-issue") == 0)
{
options.gen.conditional_issue = enable_p;
else if (strcmp (argp, "conditional-issue") == 0)
{
options.gen.conditional_issue = enable_p;
- options.warning (NULL, "Option conditional-issue replaced by gen-conditional-issue\n");
+ options.warning (NULL,
+ "Option conditional-issue replaced by gen-conditional-issue\n");
}
else if (strcmp (argp, "gen-delayed-branch") == 0)
{
else if (strcmp (argp, "delayed-branch") == 0)
{
options.gen.delayed_branch = enable_p;
- options.warning (NULL, "Option delayed-branch replaced by gen-delayed-branch\n");
+ options.warning (NULL,
+ "Option delayed-branch replaced by gen-delayed-branch\n");
}
else if (strcmp (argp, "gen-direct-access") == 0)
{
else if (strcmp (argp, "direct-access") == 0)
{
options.gen.direct_access = enable_p;
- options.warning (NULL, "Option direct-access replaced by gen-direct-access\n");
+ options.warning (NULL,
+ "Option direct-access replaced by gen-direct-access\n");
}
else if (strncmp (argp, "gen-zero-r", strlen ("gen-zero-r")) == 0)
{
{
options.gen.zero_reg = enable_p;
options.gen.zero_reg_nr = atoi (argp + strlen ("zero-r"));
- options.warning (NULL, "Option zero-r<N> replaced by gen-zero-r<N>\n");
+ options.warning (NULL,
+ "Option zero-r<N> replaced by gen-zero-r<N>\n");
}
else if (strncmp (argp, "gen-icache", strlen ("gen-icache")) == 0)
{
switch (argp[strlen ("gen-icache")])
{
case '=':
- options.gen.icache_size = atoi (argp + strlen ("gen-icache") + 1);
+ options.gen.icache_size =
+ atoi (argp + strlen ("gen-icache") + 1);
options.gen.icache = enable_p;
break;
case '\0':
options.gen.icache = enable_p;
break;
default:
- error (NULL, "Expecting -Ggen-icache or -Ggen-icache=<N>\n");
+ error (NULL,
+ "Expecting -Ggen-icache or -Ggen-icache=<N>\n");
}
}
else if (strcmp (argp, "gen-insn-in-icache") == 0)
{
options.gen.insn_in_icache = enable_p;
}
- else if (strncmp (argp, "gen-multi-sim", strlen ("gen-multi-sim")) == 0)
+ else if (strncmp (argp, "gen-multi-sim", strlen ("gen-multi-sim"))
+ == 0)
{
char *arg = &argp[strlen ("gen-multi-sim")];
switch (arg[0])
case '=':
options.gen.multi_sim = enable_p;
options.gen.default_model = arg + 1;
- if (! filter_is_member (options.model_filter, options.gen.default_model))
- error (NULL, "multi-sim model %s unknown\n", options.gen.default_model);
+ if (!filter_is_member
+ (options.model_filter, options.gen.default_model))
+ error (NULL, "multi-sim model %s unknown\n",
+ options.gen.default_model);
break;
case '\0':
options.gen.multi_sim = enable_p;
options.gen.default_model = NULL;
break;
default:
- error (NULL, "Expecting -Ggen-multi-sim or -Ggen-multi-sim=<MODEL>\n");
+ error (NULL,
+ "Expecting -Ggen-multi-sim or -Ggen-multi-sim=<MODEL>\n");
break;
}
}
else if (strcmp (argp, "verify-slot") == 0)
{
options.gen.slot_verification = enable_p;
- options.warning (NULL, "Option verify-slot replaced by gen-slot-verification\n");
+ options.warning (NULL,
+ "Option verify-slot replaced by gen-slot-verification\n");
}
else if (strcmp (argp, "gen-nia-invalid") == 0)
{
else if (strcmp (argp, "default-nia-minus-one") == 0)
{
options.gen.nia = nia_is_invalid;
- options.warning (NULL, "Option default-nia-minus-one replaced by gen-nia-invalid\n");
+ options.warning (NULL,
+ "Option default-nia-minus-one replaced by gen-nia-invalid\n");
}
else if (strcmp (argp, "gen-nia-void") == 0)
{
}
break;
}
-
+
case 'i':
isa = load_insn_table (optarg, cache_rules);
if (isa->illegal_insn == NULL)
break;
case 'n':
- real_file_name = strdup(optarg);
+ real_file_name = strdup (optarg);
break;
case 'h':
is_header = 1;
break;
-
+
case 'c':
case 'd':
case 'e':
case 's':
case 't':
{
- lf *file = lf_open(optarg, real_file_name, file_references,
- (is_header ? lf_is_h : lf_is_c),
- argv[0]);
+ lf *file = lf_open (optarg, real_file_name, file_references,
+ (is_header ? lf_is_h : lf_is_c),
+ argv[0]);
if (gen == NULL && ch != 't' && ch != 'm' && ch != 'f')
{
- options.warning (NULL, "Explicitly generate tables with -x option\n");
+ options.warning (NULL,
+ "Explicitly generate tables with -x option\n");
gen = do_gen (isa, decode_rules);
}
- lf_print__file_start(file);
+ lf_print__file_start (file);
switch (ch)
{
case 'm':
gen_run_c (file, gen);
break;
case 's':
- if(is_header)
+ if (is_header)
gen_semantics_h (file, gen->semantics, isa->max_nr_words);
else
gen_semantics_c (file, gen->semantics, isa->caches);
if (is_header)
gen_icache_h (file,
gen->semantics,
- isa->functions,
- isa->max_nr_words);
+ isa->functions, isa->max_nr_words);
else
gen_icache_c (file,
- gen->semantics,
- isa->functions,
- cache_rules);
+ gen->semantics, isa->functions, cache_rules);
break;
}
- lf_print__file_finish(file);
- lf_close(file);
+ lf_print__file_finish (file);
+ lf_close (file);
is_header = 0;
}
- real_file_name = NULL;
- break;
+ real_file_name = NULL;
+ break;
default:
ERROR ("Bad switch");
}
/* code-generation options: */
-typedef enum {
+typedef enum
+{
/* Transfer control to an instructions semantic code using the the
standard call/return mechanism */
generate_jumps,
-} igen_code;
+}
+igen_code;
-typedef enum {
+typedef enum
+{
nia_is_cia_plus_one,
nia_is_void,
nia_is_invalid,
-} igen_nia;
+}
+igen_nia;
typedef struct _igen_gen_options igen_gen_options;
-struct _igen_gen_options {
+struct _igen_gen_options
+{
int direct_access;
int semantic_icache;
int insn_in_icache;
typedef struct _igen_trace_options igen_trace_options;
-struct _igen_trace_options {
+struct _igen_trace_options
+{
int rule_selection;
int rule_rejection;
int insn_insertion;
int combine;
};
-typedef struct _igen_name {
+typedef struct _igen_name
+{
char *u;
char *l;
-} igen_name;
-typedef struct _igen_module {
+}
+igen_name;
+typedef struct _igen_module
+{
igen_name prefix;
igen_name suffix;
-} igen_module;
+}
+igen_module;
-typedef struct _igen_module_options {
+typedef struct _igen_module_options
+{
igen_module global;
igen_module engine;
igen_module icache;
igen_module itable;
igen_module semantics;
igen_module support;
-} igen_module_options;
+}
+igen_module_options;
-typedef struct _igen_decode_options igen_decode_options ;
-struct _igen_decode_options {
+typedef struct _igen_decode_options igen_decode_options;
+struct _igen_decode_options
+{
/* Combine tables? Should the generator make a second pass through
each generated table looking for any sub-entries that contain the
typedef struct _igen_warn_options igen_warn_options;
-struct _igen_warn_options {
+struct _igen_warn_options
+{
/* Issue warning about discarded instructions */
int discard;
typedef struct _igen_options igen_options;
-struct _igen_options {
+struct _igen_options
+{
/* What does the instruction look like - bit ordering, size, widths or
offesets */
extern igen_options options;
-/* default options - hopefully backward compatible */ \
+/* default options - hopefully backward compatible */
#define INIT_OPTIONS() \
do { \
memset (&options, 0, sizeof options); \
#endif
-enum {
+enum
+{
ca_type,
ca_field_name,
ca_derived_name,
};
static const name_map cache_type_map[] = {
- { "cache", cache_value },
- { "compute", compute_value },
- { "scratch", scratch_value },
- { NULL, 0 },
+ {"cache", cache_value},
+ {"compute", compute_value},
+ {"scratch", scratch_value},
+ {NULL, 0},
};
new_rule->line = entry->line;
new_rule->entry_type = name2i (entry->field[ca_type], cache_type_map);
new_rule->name = entry->field[ca_derived_name];
- filter_parse (&new_rule->original_fields,
- entry->field[ca_field_name]);
+ filter_parse (&new_rule->original_fields, entry->field[ca_field_name]);
new_rule->type = entry->field[ca_type_def];
/* expression is the concatenation of the remaining fields */
if (entry->nr_fields > ca_expression)
igen_options options;
int
-main(int argc, char **argv)
+main (int argc, char **argv)
{
cache_entry *rules = NULL;
lf *l;
new name had better be the same. */
-extern cache_entry *load_cache_table
-(char *file_name);
+extern cache_entry *load_cache_table (char *file_name);
static const name_map decode_type_map[] = {
- { "normal", normal_decode_rule },
- { "boolean", boolean_rule },
- { NULL, normal_decode_rule },
+ {"normal", normal_decode_rule},
+ {"boolean", boolean_rule},
+ {NULL, normal_decode_rule},
};
static const name_map decode_gen_map[] = {
- { "array", array_gen },
- { "switch", switch_gen },
- { "padded-switch", padded_switch_gen },
- { "goto-switch", goto_switch_gen },
- { NULL, -1 },
+ {"array", array_gen},
+ {"switch", switch_gen},
+ {"padded-switch", padded_switch_gen},
+ {"goto-switch", goto_switch_gen},
+ {NULL, -1},
};
static const name_map decode_reserved_map[] = {
- { "zero-reserved", 1 },
- { NULL, 0 },
+ {"zero-reserved", 1},
+ {NULL, 0},
};
static const name_map decode_duplicates_map[] = {
- { "duplicate", 1 },
- { NULL, 0 },
+ {"duplicate", 1},
+ {NULL, 0},
};
static const name_map decode_combine_map[] = {
- { "combine", 1 },
- { NULL, 0 },
+ {"combine", 1},
+ {NULL, 0},
};
static const name_map decode_search_map[] = {
- { "constants", decode_find_constants },
- { "mixed", decode_find_mixed },
- { "strings", decode_find_strings },
- { NULL, decode_find_mixed },
+ {"constants", decode_find_constants},
+ {"mixed", decode_find_mixed},
+ {"strings", decode_find_strings},
+ {NULL, decode_find_mixed},
};
static void
-set_bits (int bit[max_insn_bit_size],
- unsigned64 value)
+set_bits (int bit[max_insn_bit_size], unsigned64 value)
{
int bit_nr;
for (bit_nr = 0; bit_nr < max_insn_bit_size; bit_nr++)
}
decode_table *
-load_decode_table(char *file_name)
+load_decode_table (char *file_name)
{
table *file = table_open (file_name);
table_entry *entry;
/* the options field */
new_rule->type = name2i (decode_options, decode_type_map);
if (options.decode.overriding_gen != NULL)
- new_rule->gen = name2i (options.decode.overriding_gen, decode_gen_map);
+ new_rule->gen =
+ name2i (options.decode.overriding_gen, decode_gen_map);
else
new_rule->gen = name2i (decode_options, decode_gen_map);
- if (new_rule->gen == padded_switch_gen
- && options.decode.switch_as_goto)
+ if (new_rule->gen == padded_switch_gen && options.decode.switch_as_goto)
new_rule->gen = goto_switch_gen;
if (options.decode.zero_reserved)
new_rule->with_zero_reserved = 1;
else
- new_rule->with_zero_reserved = name2i (decode_options, decode_reserved_map);
+ new_rule->with_zero_reserved =
+ name2i (decode_options, decode_reserved_map);
if (options.decode.duplicate)
new_rule->with_duplicates = 1;
else
- new_rule->with_duplicates = name2i (decode_options, decode_duplicates_map);
+ new_rule->with_duplicates =
+ name2i (decode_options, decode_duplicates_map);
if (options.decode.combine)
new_rule->with_combine = 1;
else
&& strlen (entry->field[decode_force_first_field]) > 0)
{
new_rule->force_first = target_a2i (options.hi_bit_nr,
- entry->field[decode_force_first_field]);
+ entry->
+ field
+ [decode_force_first_field]);
if (new_rule->force_first < new_rule->first
|| new_rule->force_first > new_rule->last + 1)
error (new_rule->line, "Force first out of range\n");
&& strlen (entry->field[decode_force_last_field]) > 0)
{
new_rule->force_last = target_a2i (options.hi_bit_nr,
- entry->field[decode_force_last_field]);
+ entry->
+ field[decode_force_last_field]);
if (new_rule->force_last > new_rule->last
|| new_rule->force_last < new_rule->first - 1)
error (new_rule->line, "Force-last out of range\n");
{
(*last) = ZALLOC (decode_path_list);
/* extra root/zero entry */
- (*last)->path = ZALLOC (decode_path);
+ (*last)->path = ZALLOC (decode_path);
do
{
decode_path *entry = ZALLOC (decode_path);
decode_cond *cond = ZALLOC (decode_cond);
decode_cond **last;
if (entry->nr_fields > field_nr + decode_cond_mask_field)
- set_bits (cond->mask, a2i (entry->field[field_nr + decode_cond_mask_field]));
+ set_bits (cond->mask,
+ a2i (entry->
+ field[field_nr + decode_cond_mask_field]));
if (entry->nr_fields > field_nr + decode_cond_value_field)
- {
- if (entry->field[field_nr + decode_cond_value_field][0] == '!')
- {
- cond->is_equal = 0;
- set_bits (cond->value, a2i (entry->field[field_nr + decode_cond_value_field] + 1));
- }
- else
- {
- cond->is_equal = 1;
- set_bits (cond->value, a2i (entry->field[field_nr + decode_cond_value_field]));
- }
- }
+ {
+ if (entry->field[field_nr + decode_cond_value_field][0] ==
+ '!')
+ {
+ cond->is_equal = 0;
+ set_bits (cond->value,
+ a2i (entry->
+ field[field_nr + decode_cond_value_field] +
+ 1));
+ }
+ else
+ {
+ cond->is_equal = 1;
+ set_bits (cond->value,
+ a2i (entry->
+ field[field_nr +
+ decode_cond_value_field]));
+ }
+ }
if (entry->nr_fields > field_nr + decode_cond_word_nr_field)
- cond->word_nr = a2i (entry->field[field_nr + decode_cond_word_nr_field]);
+ cond->word_nr =
+ a2i (entry->field[field_nr + decode_cond_word_nr_field]);
field_nr += nr_decode_cond_fields;
/* insert it */
last = &new_rule->conditions;
return table;
}
-
+
int
decode_table_max_word_nr (decode_table *entry)
{
static void
-dump_decode_cond (lf *file,
- char *prefix,
- decode_cond *cond,
- char *suffix)
+dump_decode_cond (lf *file, char *prefix, decode_cond *cond, char *suffix)
{
lf_printf (file, "%s(decode_cond *) 0x%lx", prefix, (long) cond);
if (cond != NULL)
static void
-dump_decode_conds (lf *file,
- char *prefix,
- decode_cond *cond,
- char *suffix)
+dump_decode_conds (lf *file, char *prefix, decode_cond *cond, char *suffix)
{
lf_printf (file, "%s(decode_cond *) 0x%lx", prefix, (long) cond);
while (cond != NULL)
void
-dump_decode_rule (lf *file,
- char *prefix,
- decode_table *rule,
- char *suffix)
+dump_decode_rule (lf *file, char *prefix, decode_table *rule, char *suffix)
{
lf_printf (file, "%s(decode_table *) 0x%lx", prefix, (long) rule);
if (rule != NULL)
{
lf_indent (file, +1);
dump_line_ref (file, "\n(line ", rule->line, ")");
- lf_printf (file, "\n(type %s)", i2name(rule->type, decode_type_map));
- lf_printf (file, "\n(gen %s)", i2name(rule->gen, decode_gen_map));
+ lf_printf (file, "\n(type %s)", i2name (rule->type, decode_type_map));
+ lf_printf (file, "\n(gen %s)", i2name (rule->gen, decode_gen_map));
lf_printf (file, "\n(first %d)", rule->first);
lf_printf (file, "\n(last %d)", rule->last);
lf_printf (file, "\n(force_first %d)", rule->force_first);
lf_printf (file, "\n(force_last %d)", rule->force_last);
- dump_filter (file, "\n(constant_field_names \"", rule->constant_field_names, "\")");
+ dump_filter (file, "\n(constant_field_names \"",
+ rule->constant_field_names, "\")");
lf_printf (file, "\n(constant 0x%x)", rule->constant);
lf_printf (file, "\n(word_nr %d)", rule->word_nr);
lf_printf (file, "\n(with_zero_reserved %d)", rule->with_zero_reserved);
#ifdef MAIN
static void
-dump_decode_rules (lf *file,
- char *prefix,
- decode_table *rule,
- char *suffix)
+dump_decode_rules (lf *file, char *prefix, decode_table *rule, char *suffix)
{
lf_printf (file, "%s", prefix);
while (rule != NULL)
igen_options options;
int
-main(int argc, char **argv)
+main (int argc, char **argv)
{
lf *l;
decode_table *rules;
*/
-typedef enum {
+typedef enum
+{
normal_decode_rule,
boolean_rule,
-} decode_special_type;
+}
+decode_special_type;
-typedef enum {
+typedef enum
+{
invalid_gen,
array_gen,
switch_gen,
padded_switch_gen,
goto_switch_gen,
-} decode_gen_type;
+}
+decode_gen_type;
-enum {
+enum
+{
decode_cond_mask_field,
decode_cond_value_field,
decode_cond_word_nr_field,
};
typedef struct _decode_path decode_path;
-struct _decode_path {
+struct _decode_path
+{
int opcode_nr;
decode_path *parent;
};
typedef struct _decode_path_list decode_path_list;
-struct _decode_path_list {
+struct _decode_path_list
+{
decode_path *path;
decode_path_list *next;
};
typedef struct _decode_cond decode_cond;
-struct _decode_cond {
+struct _decode_cond
+{
int word_nr;
int mask[max_insn_bit_size];
int value[max_insn_bit_size];
decode_cond *next;
};
-typedef enum {
+typedef enum
+{
decode_find_mixed,
decode_find_constants,
decode_find_strings,
-} decode_search_type;
+}
+decode_search_type;
-enum {
+enum
+{
decode_options_field,
decode_first_field,
decode_last_field,
typedef struct _decode_table decode_table;
-struct _decode_table {
+struct _decode_table
+{
line_ref *line;
decode_special_type type;
decode_gen_type gen;
};
-extern decode_table *load_decode_table
-(char *file_name);
+extern decode_table *load_decode_table (char *file_name);
-extern int decode_table_max_word_nr
-(decode_table *rule);
+extern int decode_table_max_word_nr (decode_table *rule);
extern void dump_decode_rule
-(lf *file,
- char *prefix,
- decode_table *rule,
- char *suffix);
+ (lf *file, char *prefix, decode_table *rule, char *suffix);
#include "ld-insn.h"
static insn_word_entry *
-parse_insn_word (line_ref *line,
- char *string,
- int word_nr)
+parse_insn_word (line_ref *line, char *string, int word_nr)
{
char *chp;
insn_word_entry *word = ZALLOC (insn_word_entry);
/* now work through the formats */
chp = skip_spaces (string);
- while (*chp != '\0') {
- char *start_pos;
- int strlen_pos;
- char *start_val;
- int strlen_val;
- insn_field_entry *new_field;
-
- /* create / link in the new field */
- new_field = ZALLOC (insn_field_entry);
- new_field->next = word->last;
- new_field->prev = word->last->prev;
- new_field->next->prev = new_field;
- new_field->prev->next = new_field;
- new_field->word_nr = word_nr;
-
- /* break out the first field (if present) */
- start_pos = chp;
- chp = skip_to_separator (chp, ".,!");
- strlen_pos = back_spaces (start_pos, chp) - start_pos;
-
- /* break out the second field (if present) */
- if (*chp != '.')
- {
- /* assume what was specified was the value (and not the start
- position). Assume the value length implicitly specifies
- the number of bits */
- start_val = start_pos;
- strlen_val = strlen_pos;
- start_pos = "";
- strlen_pos = 0;
- }
- else
- {
- chp++; /* skip `.' */
- chp = skip_spaces (chp);
- start_val = chp;
- if (*chp == '/' || *chp == '*')
- {
- do
- {
- chp++;
- }
- while (*chp == '/' || *chp == '*');
- }
- else if (isalpha(*start_val))
- {
- do
- {
- chp++;
- }
- while (isalnum(*chp) || *chp == '_');
- }
- else if (isdigit(*start_val))
- {
- do {
- chp++;
+ while (*chp != '\0')
+ {
+ char *start_pos;
+ int strlen_pos;
+ char *start_val;
+ int strlen_val;
+ insn_field_entry *new_field;
+
+ /* create / link in the new field */
+ new_field = ZALLOC (insn_field_entry);
+ new_field->next = word->last;
+ new_field->prev = word->last->prev;
+ new_field->next->prev = new_field;
+ new_field->prev->next = new_field;
+ new_field->word_nr = word_nr;
+
+ /* break out the first field (if present) */
+ start_pos = chp;
+ chp = skip_to_separator (chp, ".,!");
+ strlen_pos = back_spaces (start_pos, chp) - start_pos;
+
+ /* break out the second field (if present) */
+ if (*chp != '.')
+ {
+ /* assume what was specified was the value (and not the start
+ position). Assume the value length implicitly specifies
+ the number of bits */
+ start_val = start_pos;
+ strlen_val = strlen_pos;
+ start_pos = "";
+ strlen_pos = 0;
+ }
+ else
+ {
+ chp++; /* skip `.' */
+ chp = skip_spaces (chp);
+ start_val = chp;
+ if (*chp == '/' || *chp == '*')
+ {
+ do
+ {
+ chp++;
+ }
+ while (*chp == '/' || *chp == '*');
}
- while (isalnum(*chp));
- }
- strlen_val = chp - start_val;
- chp = skip_spaces (chp);
- }
- if (strlen_val == 0)
- error (line, "Empty value field\n");
-
- /* break out any conditional fields - { [ "!" | "=" [ <value> | <field-name> } */
- while (*chp == '!' || *chp == '=')
- {
- char *start;
- char *end;
- int len;
- insn_field_cond *new_cond = ZALLOC (insn_field_cond);
-
- /* determine the conditional test */
- switch (*chp)
- {
- case '=':
- new_cond->test = insn_field_cond_eq;
- break;
- case '!':
- new_cond->test = insn_field_cond_ne;
- break;
- default:
- ASSERT (0);
- }
-
- /* save the value */
- chp++;
- chp = skip_spaces (chp);
- start = chp;
- chp = skip_to_separator (chp, "+,:!=");
- end = back_spaces (start, chp);
- len = end - start;
- if (len == 0)
- error (line, "Missing or invalid conditional value\n");
- new_cond->string = NZALLOC (char, len + 1);
- strncpy (new_cond->string, start, len);
-
- /* determine the conditional type */
- if (isdigit (*start))
- {
- /* [ "!" | "=" ] <value> */
- new_cond->type = insn_field_cond_value;
- new_cond->value = a2i (new_cond->string);
- }
- else
+ else if (isalpha (*start_val))
+ {
+ do
+ {
+ chp++;
+ }
+ while (isalnum (*chp) || *chp == '_');
+ }
+ else if (isdigit (*start_val))
+ {
+ do
+ {
+ chp++;
+ }
+ while (isalnum (*chp));
+ }
+ strlen_val = chp - start_val;
+ chp = skip_spaces (chp);
+ }
+ if (strlen_val == 0)
+ error (line, "Empty value field\n");
+
+ /* break out any conditional fields - { [ "!" | "=" [ <value> | <field-name> } */
+ while (*chp == '!' || *chp == '=')
+ {
+ char *start;
+ char *end;
+ int len;
+ insn_field_cond *new_cond = ZALLOC (insn_field_cond);
+
+ /* determine the conditional test */
+ switch (*chp)
+ {
+ case '=':
+ new_cond->test = insn_field_cond_eq;
+ break;
+ case '!':
+ new_cond->test = insn_field_cond_ne;
+ break;
+ default:
+ ASSERT (0);
+ }
+
+ /* save the value */
+ chp++;
+ chp = skip_spaces (chp);
+ start = chp;
+ chp = skip_to_separator (chp, "+,:!=");
+ end = back_spaces (start, chp);
+ len = end - start;
+ if (len == 0)
+ error (line, "Missing or invalid conditional value\n");
+ new_cond->string = NZALLOC (char, len + 1);
+ strncpy (new_cond->string, start, len);
+
+ /* determine the conditional type */
+ if (isdigit (*start))
+ {
+ /* [ "!" | "=" ] <value> */
+ new_cond->type = insn_field_cond_value;
+ new_cond->value = a2i (new_cond->string);
+ }
+ else
+ {
+ /* [ "!" | "=" ] <field> - check field valid */
+ new_cond->type = insn_field_cond_field;
+ /* new_cond->field is determined in later */
+ }
+
+ /* Only a single `=' is permitted. */
+ if ((new_cond->test == insn_field_cond_eq
+ && new_field->conditions != NULL)
+ || (new_field->conditions != NULL
+ && new_field->conditions->test == insn_field_cond_eq))
+ error (line, "Only single conditional when `=' allowed\n");
+
+ /* insert it */
{
- /* [ "!" | "=" ] <field> - check field valid */
- new_cond->type = insn_field_cond_field;
- /* new_cond->field is determined in later */
+ insn_field_cond **last = &new_field->conditions;
+ while (*last != NULL)
+ last = &(*last)->next;
+ *last = new_cond;
}
-
- /* Only a single `=' is permitted. */
- if ((new_cond->test == insn_field_cond_eq
- && new_field->conditions != NULL)
- || (new_field->conditions != NULL
- && new_field->conditions->test == insn_field_cond_eq))
- error (line, "Only single conditional when `=' allowed\n");
-
- /* insert it */
+ }
+
+ /* NOW verify that the field was finished */
+ if (*chp == ',')
{
- insn_field_cond **last = &new_field->conditions;
- while (*last != NULL)
- last = &(*last)->next;
- *last = new_cond;
+ chp = skip_spaces (chp + 1);
+ if (*chp == '\0')
+ error (line, "empty field\n");
+ }
+ else if (*chp != '\0')
+ {
+ error (line, "Missing field separator\n");
}
- }
- /* NOW verify that the field was finished */
- if (*chp == ',')
- {
- chp = skip_spaces (chp + 1);
- if (*chp == '\0')
- error (line, "empty field\n");
- }
- else if (*chp != '\0')
- {
- error (line, "Missing field separator\n");
- }
+ /* copy the value */
+ new_field->val_string = NZALLOC (char, strlen_val + 1);
+ strncpy (new_field->val_string, start_val, strlen_val);
+ if (isdigit (new_field->val_string[0]))
+ {
+ if (strlen_pos == 0)
+ {
+ /* when the length/pos field is omited, an integer field
+ is always binary */
+ unsigned64 val = 0;
+ int i;
+ for (i = 0; i < strlen_val; i++)
+ {
+ if (new_field->val_string[i] != '0'
+ && new_field->val_string[i] != '1')
+ error (line, "invalid binary field %s\n",
+ new_field->val_string);
+ val = (val << 1) + (new_field->val_string[i] == '1');
+ }
+ new_field->val_int = val;
+ new_field->type = insn_field_int;
+ }
+ else
+ {
+ new_field->val_int = a2i (new_field->val_string);
+ new_field->type = insn_field_int;
+ }
+ }
+ else if (new_field->val_string[0] == '/')
+ {
+ new_field->type = insn_field_reserved;
+ }
+ else if (new_field->val_string[0] == '*')
+ {
+ new_field->type = insn_field_wild;
+ }
+ else
+ {
+ new_field->type = insn_field_string;
+ if (filter_is_member (word->field_names, new_field->val_string))
+ error (line, "Field name %s is duplicated\n",
+ new_field->val_string);
+ filter_parse (&word->field_names, new_field->val_string);
+ }
+ if (new_field->type != insn_field_string
+ && new_field->conditions != NULL)
+ error (line, "Conditionals can only be applied to named fields\n");
- /* copy the value */
- new_field->val_string = NZALLOC (char, strlen_val+1);
- strncpy (new_field->val_string, start_val, strlen_val);
- if (isdigit (new_field->val_string[0]))
- {
- if (strlen_pos == 0)
- {
- /* when the length/pos field is omited, an integer field
- is always binary */
- unsigned64 val = 0;
- int i;
- for (i = 0; i < strlen_val; i++)
- {
- if (new_field->val_string[i] != '0'
- && new_field->val_string[i] != '1')
- error (line, "invalid binary field %s\n",
- new_field->val_string);
- val = (val << 1) + (new_field->val_string[i] == '1');
- }
- new_field->val_int = val;
- new_field->type = insn_field_int;
- }
- else
- {
- new_field->val_int = a2i (new_field->val_string);
- new_field->type = insn_field_int;
- }
- }
- else if (new_field->val_string[0] == '/')
- {
- new_field->type = insn_field_reserved;
- }
- else if (new_field->val_string[0] == '*')
- {
- new_field->type = insn_field_wild;
- }
- else
- {
- new_field->type = insn_field_string;
- if (filter_is_member (word->field_names, new_field->val_string))
- error (line, "Field name %s is duplicated\n", new_field->val_string);
- filter_parse (&word->field_names, new_field->val_string);
- }
- if (new_field->type != insn_field_string
- && new_field->conditions != NULL)
- error (line, "Conditionals can only be applied to named fields\n");
-
- /* the copy the position */
- new_field->pos_string = NZALLOC (char, strlen_pos + 1);
- strncpy (new_field->pos_string, start_pos, strlen_pos);
- if (strlen_pos == 0)
- {
- new_field->first = new_field->prev->last + 1;
- if (new_field->first == 0 /* first field */
- && *chp == '\0' /* no further fields */
- && new_field->type == insn_field_string)
- {
- /* A single string without any position, assume that it
- represents the entire instruction word */
- new_field->width = options.insn_bit_size;
- }
- else
- {
- /* No explicit width/position, assume value implicitly
- supplies the width */
- new_field->width = strlen_val;
- }
- new_field->last = new_field->first + new_field->width - 1;
- if (new_field->last >= options.insn_bit_size)
- error (line, "Bit position %d exceed instruction bit size (%d)\n",
- new_field->last, options.insn_bit_size);
- }
- else if (options.insn_specifying_widths)
- {
- new_field->first = new_field->prev->last + 1;
- new_field->width = a2i(new_field->pos_string);
- new_field->last = new_field->first + new_field->width - 1;
- if (new_field->last >= options.insn_bit_size)
- error (line, "Bit position %d exceed instruction bit size (%d)\n",
- new_field->last, options.insn_bit_size);
- }
- else
- {
- new_field->first = target_a2i(options.hi_bit_nr,
- new_field->pos_string);
- new_field->last = new_field->next->first - 1; /* guess */
- new_field->width = new_field->last - new_field->first + 1; /* guess */
- new_field->prev->last = new_field->first - 1; /*fix*/
- new_field->prev->width = new_field->first - new_field->prev->first; /*fix*/
- }
- }
+ /* the copy the position */
+ new_field->pos_string = NZALLOC (char, strlen_pos + 1);
+ strncpy (new_field->pos_string, start_pos, strlen_pos);
+ if (strlen_pos == 0)
+ {
+ new_field->first = new_field->prev->last + 1;
+ if (new_field->first == 0 /* first field */
+ && *chp == '\0' /* no further fields */
+ && new_field->type == insn_field_string)
+ {
+ /* A single string without any position, assume that it
+ represents the entire instruction word */
+ new_field->width = options.insn_bit_size;
+ }
+ else
+ {
+ /* No explicit width/position, assume value implicitly
+ supplies the width */
+ new_field->width = strlen_val;
+ }
+ new_field->last = new_field->first + new_field->width - 1;
+ if (new_field->last >= options.insn_bit_size)
+ error (line, "Bit position %d exceed instruction bit size (%d)\n",
+ new_field->last, options.insn_bit_size);
+ }
+ else if (options.insn_specifying_widths)
+ {
+ new_field->first = new_field->prev->last + 1;
+ new_field->width = a2i (new_field->pos_string);
+ new_field->last = new_field->first + new_field->width - 1;
+ if (new_field->last >= options.insn_bit_size)
+ error (line, "Bit position %d exceed instruction bit size (%d)\n",
+ new_field->last, options.insn_bit_size);
+ }
+ else
+ {
+ new_field->first = target_a2i (options.hi_bit_nr,
+ new_field->pos_string);
+ new_field->last = new_field->next->first - 1; /* guess */
+ new_field->width = new_field->last - new_field->first + 1; /* guess */
+ new_field->prev->last = new_field->first - 1; /*fix */
+ new_field->prev->width = new_field->first - new_field->prev->first; /*fix */
+ }
+ }
/* fiddle first/last so that the sentinals disapear */
- ASSERT(word->first->last < 0);
- ASSERT(word->last->first >= options.insn_bit_size);
+ ASSERT (word->first->last < 0);
+ ASSERT (word->last->first >= options.insn_bit_size);
word->first = word->first->next;
word->last = word->last->prev;
{
insn_field_entry *field;
for (field = word->first;
- field->last < options.insn_bit_size;
- field = field->next)
+ field->last < options.insn_bit_size; field = field->next)
{
int i;
for (i = field->first; i <= field->last; i++)
case insn_field_int:
word->bit[i]->mask = 1;
word->bit[i]->value = ((field->val_int
- & ((insn_uint)1 << (field->last - i)))
- != 0);
+ & ((insn_uint) 1 <<
+ (field->last - i))) != 0);
case insn_field_reserved:
case insn_field_wild:
case insn_field_string:
/* if we encounter a constant conditional, encode
- their bit value. */
+ their bit value. */
if (field->conditions != NULL
&& field->conditions->test == insn_field_cond_eq
&& field->conditions->type == insn_field_cond_value)
{
word->bit[i]->mask = 1;
word->bit[i]->value = ((field->conditions->value
- & ((insn_uint)1 << (field->last - i)))
- != 0);
+ & ((insn_uint) 1 <<
+ (field->last - i))) != 0);
}
break;
}
static void
-parse_insn_words (insn_entry *insn,
- char *formats)
+parse_insn_words (insn_entry * insn, char *formats)
{
insn_word_entry **last_word = &insn->words;
char *chp;
insn_word_entry *word;
insn->word = NZALLOC (insn_word_entry *, insn->nr_words + 1);
for (i = 0, word = insn->words;
- i < insn->nr_words;
- i++, word = word->next)
+ i < insn->nr_words; i++, word = word->next)
insn->word[i] = word;
}
{
insn_word_entry *word = insn->word[i];
insn_field_entry *f;
- for (f = word->first;
- f->last < options.insn_bit_size;
- f = f->next)
+ for (f = word->first; f->last < options.insn_bit_size; f = f->next)
{
insn_field_cond *cond;
- for (cond = f->conditions;
- cond != NULL;
- cond = cond->next)
+ for (cond = f->conditions; cond != NULL; cond = cond->next)
{
if (cond->type == insn_field_cond_field)
{
refered_field = refered_field->next)
{
if (refered_field->type == insn_field_string
- && strcmp (refered_field->val_string, cond->string) == 0)
+ && strcmp (refered_field->val_string,
+ cond->string) == 0)
{
/* found field being refered to by conditonal */
cond->field = refered_field;
if (f->width != refered_field->width)
error (insn->line,
"Conditional `%s' of field `%s' should be of size %s\n",
- cond->string, f->val_string, refered_field->width);
+ cond->string, f->val_string,
+ refered_field->width);
}
}
}
}
}
}
-
+
}
-typedef enum {
+typedef enum
+{
unknown_record = 0,
- insn_record, /* default */
+ insn_record, /* default */
code_record,
cache_record,
compute_record,
model_static_record,
model_function_record,
model_internal_record,
-} insn_record_type;
+}
+insn_record_type;
static const name_map insn_type_map[] = {
- { "option", option_record },
- { "cache", cache_record },
- { "compute", compute_record },
- { "scratch", scratch_record },
- { "define", define_record },
- { "include", include_record },
- { "%s", string_function_record },
- { "function", function_record },
- { "internal", internal_record },
- { "model", model_processor_record },
- { "model-macro", model_macro_record },
- { "model-data", model_data_record },
- { "model-static", model_static_record },
- { "model-internal", model_internal_record },
- { "model-function", model_function_record },
- { NULL, insn_record },
+ {"option", option_record},
+ {"cache", cache_record},
+ {"compute", compute_record},
+ {"scratch", scratch_record},
+ {"define", define_record},
+ {"include", include_record},
+ {"%s", string_function_record},
+ {"function", function_record},
+ {"internal", internal_record},
+ {"model", model_processor_record},
+ {"model-macro", model_macro_record},
+ {"model-data", model_data_record},
+ {"model-static", model_static_record},
+ {"model-internal", model_internal_record},
+ {"model-function", model_function_record},
+ {NULL, insn_record},
};
return i;
}
else
- return insn_record; /* default */
+ return insn_record; /* default */
}
return unknown_record;
}
static int
-record_prefix_is (table_entry *entry,
- char ch,
- int nr_fields)
+record_prefix_is (table_entry *entry, char ch, int nr_fields)
{
if (entry->type != table_colon_entry)
return 0;
parse_model_data_record (insn_table *isa,
table *file,
table_entry *record,
- int nr_fields,
- model_data **list)
+ int nr_fields, model_data **list)
{
table_entry *model_record = record;
table_entry *code_record = NULL;
}
-typedef enum {
+typedef enum
+{
insn_bit_size_option = 1,
insn_specifying_widths_option,
hi_bit_nr_option,
format_names_option,
gen_delayed_branch,
unknown_option,
-} option_names;
+}
+option_names;
static const name_map option_map[] = {
- { "insn-bit-size", insn_bit_size_option },
- { "insn-specifying-widths", insn_specifying_widths_option },
- { "hi-bit-nr", hi_bit_nr_option },
- { "flags-filter", flags_filter_option },
- { "model-filter", model_filter_option },
- { "multi-sim", multi_sim_option },
- { "format-names", format_names_option },
- { "gen-delayed-branch", gen_delayed_branch },
- { NULL, unknown_option },
+ {"insn-bit-size", insn_bit_size_option},
+ {"insn-specifying-widths", insn_specifying_widths_option},
+ {"hi-bit-nr", hi_bit_nr_option},
+ {"flags-filter", flags_filter_option},
+ {"model-filter", model_filter_option},
+ {"multi-sim", multi_sim_option},
+ {"format-names", format_names_option},
+ {"gen-delayed-branch", gen_delayed_branch},
+ {NULL, unknown_option},
};
static table_entry *
-parse_include_record (table *file,
- table_entry *record)
+parse_include_record (table *file, table_entry *record)
{
/* parse the include record */
if (record->nr_fields < nr_include_fields)
{
table_push (file, record->line, options.include,
record->field[include_filename_field]);
- }
+ }
/* nb: can't read next record until after the file has been pushed */
record = table_read (file);
return record;
static table_entry *
-parse_option_record (table *file,
- table_entry *record)
+parse_option_record (table *file, table_entry *record)
{
table_entry *option_record;
/* parse the option record */
options.insn_bit_size = a2i (value);
if (options.insn_bit_size < 0
|| options.insn_bit_size > max_insn_bit_size)
- error (option_record->line, "Instruction bit size out of range\n");
+ error (option_record->line,
+ "Instruction bit size out of range\n");
if (options.hi_bit_nr != options.insn_bit_size - 1
&& options.hi_bit_nr != 0)
- error (option_record->line, "insn-bit-size / hi-bit-nr conflict\n");
+ error (option_record->line,
+ "insn-bit-size / hi-bit-nr conflict\n");
break;
}
case insn_specifying_widths_option:
options.hi_bit_nr = a2i (value);
if (options.hi_bit_nr != 0
&& options.hi_bit_nr != options.insn_bit_size - 1)
- error (option_record->line, "hi-bit-nr / insn-bit-size conflict\n");
+ error (option_record->line,
+ "hi-bit-nr / insn-bit-size conflict\n");
break;
}
case flags_filter_option:
break;
}
}
- }
+ }
return record;
}
static table_entry *
parse_function_record (table *file,
table_entry *record,
- function_entry **list,
- function_entry **list_entry,
- int is_internal,
- model_table *model)
+ function_entry ** list,
+ function_entry ** list_entry,
+ int is_internal, model_table *model)
{
function_entry *new_function;
new_function = ZALLOC (function_entry);
while (record != NULL
&& record_prefix_is (record, '*', nr_function_model_fields))
{
- char *model_name = record->field[function_model_name_field] + 1; /*skip `*'*/
+ char *model_name = record->field[function_model_name_field] + 1; /*skip `*' */
filter_parse (&new_function->models, model_name);
if (!filter_is_subset (model->processors, new_function->models))
{
&& !filter_is_common (options.model_filter, new_function->models))
{
if (options.warn.discard)
- notify (new_function->line, "Discarding function %s - filter models\n",
+ notify (new_function->line,
+ "Discarding function %s - filter models\n",
new_function->name);
}
else
static void
parse_insn_model_record (table *file,
table_entry *record,
- insn_entry *insn,
- model_table *model)
+ insn_entry * insn, model_table *model)
{
insn_model_entry **last_insn_model;
insn_model_entry *new_insn_model = ZALLOC (insn_model_entry);
/* parse the model names, verify that all were defined */
new_insn_model->names = NULL;
filter_parse (&new_insn_model->names,
- record->field[insn_model_name_field] + 1 /*skip `*'*/);
+ record->field[insn_model_name_field] + 1 /*skip `*' */ );
if (new_insn_model->names == NULL)
{
/* No processor names - a generic model entry, enter it into all
- the non-empty fields */
+ the non-empty fields */
int index;
for (index = 0; index < model->nr_models; index++)
if (insn->model[index] == 0)
while (1)
{
name = filter_next (new_insn_model->names, name);
- if (name == NULL) break;
+ if (name == NULL)
+ break;
index = filter_is_member (model->processors, name) - 1;
if (index < 0)
{
"machine model `%s' undefined\n", name);
}
/* store it in the corresponding model array entry */
- if (insn->model[index] != NULL
- && insn->model[index]->names != NULL)
+ if (insn->model[index] != NULL && insn->model[index]->names != NULL)
{
warning (new_insn_model->line,
"machine model `%s' previously defined\n", name);
static void
parse_insn_mnemonic_record (table *file,
- table_entry *record,
- insn_entry *insn)
+ table_entry *record, insn_entry * insn)
{
insn_mnemonic_entry **last_insn_mnemonic;
insn_mnemonic_entry *new_insn_mnemonic = ZALLOC (insn_mnemonic_entry);
ASSERT (record->nr_fields > insn_mnemonic_format_field);
new_insn_mnemonic->format = record->field[insn_mnemonic_format_field];
ASSERT (new_insn_mnemonic->format[0] == '"');
- if (new_insn_mnemonic->format[strlen (new_insn_mnemonic->format) - 1] != '"')
- error (new_insn_mnemonic->line, "Missing closing double quote in mnemonic field\n");
+ if (new_insn_mnemonic->format[strlen (new_insn_mnemonic->format) - 1] !=
+ '"')
+ error (new_insn_mnemonic->line,
+ "Missing closing double quote in mnemonic field\n");
if (record->nr_fields > insn_mnemonic_condition_field)
- new_insn_mnemonic->condition = record->field[insn_mnemonic_condition_field];
+ new_insn_mnemonic->condition =
+ record->field[insn_mnemonic_condition_field];
new_insn_mnemonic->insn = insn;
/* insert it */
last_insn_mnemonic = &insn->mnemonics;
static table_entry *
-parse_macro_record (table *file,
- table_entry *record)
+parse_macro_record (table *file, table_entry *record)
{
#if 1
error (record->line, "Macros are not implemented");
record->field[macro_name_field],
record->field[macro_args_field],
record->field[macro_expr_field]);
- }
+ }
record = table_read (file);
#endif
return record;
insn_table *
-load_insn_table (char *file_name,
- cache_entry *cache)
+load_insn_table (char *file_name, cache_entry *cache)
{
table *file = table_open (file_name);
table_entry *record = table_read (file);
insn_table *isa = ZALLOC (insn_table);
model_table *model = ZALLOC (model_table);
-
+
isa->model = model;
isa->caches = cache;
record = parse_option_record (file, record);
break;
}
-
+
case string_function_record:
{
function_entry *function = NULL;
record = parse_function_record (file, record,
&isa->functions,
- &function,
- 0/*is-internal*/,
+ &function, 0 /*is-internal */ ,
model);
/* convert a string function record into an internal function */
if (function != NULL)
{
char *name = NZALLOC (char,
(strlen ("str_")
- + strlen (function->name)
- + 1));
+ + strlen (function->name) + 1));
strcat (name, "str_");
strcat (name, function->name);
function->name = name;
}
break;
}
-
- case function_record: /* function record */
+
+ case function_record: /* function record */
{
record = parse_function_record (file, record,
&isa->functions,
- NULL,
- 0/*is-internal*/,
+ NULL, 0 /*is-internal */ ,
model);
break;
}
function_entry *function = NULL;
record = parse_function_record (file, record,
&isa->functions,
- &function,
- 1/*is-internal*/,
+ &function, 1 /*is-internal */ ,
model);
/* check what was inserted to see if a pseudo-instruction
- entry also needs to be created */
+ entry also needs to be created */
if (function != NULL)
{
insn_entry **insn = NULL;
}
break;
}
-
- case scratch_record: /* cache macro records */
+
+ case scratch_record: /* cache macro records */
case cache_record:
case compute_record:
{
/* insert it but only if not filtered out */
if (!filter_is_subset (options.flags_filter, new_cache->flags))
{
- notify (new_cache->line, "Discarding cache entry %s - filter flags\n",
+ notify (new_cache->line,
+ "Discarding cache entry %s - filter flags\n",
new_cache->name);
}
else if (is_filtered_out (options.model_filter,
- record->field[record_filter_models_field]))
+ record->
+ field[record_filter_models_field]))
{
- notify (new_cache->line, "Discarding cache entry %s - filter models\n",
+ notify (new_cache->line,
+ "Discarding cache entry %s - filter models\n",
new_cache->name);
}
else
record = table_read (file);
break;
}
-
- /* model records */
+
+ /* model records */
case model_processor_record:
{
model_entry *new_model;
/* parse the model */
if (record->nr_fields < nr_model_processor_fields)
- error (record->line, "Incorrect nr of fields for model record\n");
+ error (record->line,
+ "Incorrect nr of fields for model record\n");
if (isa->insns != NULL)
error (record->line, "Model appears after first instruction\n");
new_model = ZALLOC (model_entry);
/* only insert it if not filtered out */
if (!filter_is_subset (options.flags_filter, new_model->flags))
{
- notify (new_model->line, "Discarding processor model %s - filter flags\n",
+ notify (new_model->line,
+ "Discarding processor model %s - filter flags\n",
new_model->name);
}
else if (is_filtered_out (options.model_filter,
- record->field[record_filter_models_field]))
+ record->
+ field[record_filter_models_field]))
{
- notify (new_model->line, "Discarding processor model %s - filter models\n",
+ notify (new_model->line,
+ "Discarding processor model %s - filter models\n",
new_model->name);
}
else if (filter_is_member (model->processors, new_model->name))
last = &(*last)->next;
*last = new_model;
/* count it */
- model->nr_models ++;
+ model->nr_models++;
filter_parse (&model->processors, new_model->name);
}
/* advance things */
record = table_read (file);
}
break;
-
+
case model_macro_record:
record = parse_model_data_record (isa, file, record,
nr_model_macro_fields,
&model->macros);
break;
-
+
case model_data_record:
record = parse_model_data_record (isa, file, record,
nr_model_data_fields,
&model->data);
break;
-
+
case model_static_record:
record = parse_function_record (file, record,
&model->statics,
- NULL,
- 0/*is internal*/,
+ NULL, 0 /*is internal */ ,
model);
break;
-
+
case model_internal_record:
record = parse_function_record (file, record,
&model->internals,
- NULL,
- 1/*is internal*/,
+ NULL, 1 /*is internal */ ,
model);
break;
-
+
case model_function_record:
record = parse_function_record (file, record,
&model->functions,
- NULL,
- 0/*is internal*/,
+ NULL, 0 /*is internal */ ,
model);
break;
-
- case insn_record: /* instruction records */
+
+ case insn_record: /* instruction records */
{
insn_entry *new_insn;
char *format;
/* parse the instruction */
if (record->nr_fields < nr_insn_fields)
- error (record->line, "Incorrect nr of fields for insn record\n");
+ error (record->line,
+ "Incorrect nr of fields for insn record\n");
new_insn = ZALLOC (insn_entry);
new_insn->line = record->line;
filter_parse (&new_insn->flags,
record->field[record_filter_flags_field]);
/* save the format field. Can't parse it until after the
- filter-out checks. Could be filtered out because the
- format is invalid */
+ filter-out checks. Could be filtered out because the
+ format is invalid */
format = record->field[insn_word_field];
new_insn->format_name = record->field[insn_format_name_field];
if (options.format_name_filter != NULL
&& !filter_is_member (options.format_name_filter,
new_insn->format_name))
- error (new_insn->line, "Unreconized instruction format name `%s'\n",
+ error (new_insn->line,
+ "Unreconized instruction format name `%s'\n",
new_insn->format_name);
filter_parse (&new_insn->options,
record->field[insn_options_field]);
record = table_read (file);
/* Parse any model/assember records */
new_insn->nr_models = model->nr_models;
- new_insn->model = NZALLOC (insn_model_entry*, model->nr_models + 1);
+ new_insn->model =
+ NZALLOC (insn_model_entry *, model->nr_models + 1);
while (record != NULL)
{
if (record_prefix_is (record, '*', nr_insn_model_fields))
parse_insn_model_record (file, record, new_insn, model);
- else if (record_prefix_is (record, '"', nr_insn_mnemonic_fields))
+ else
+ if (record_prefix_is (record, '"', nr_insn_mnemonic_fields))
parse_insn_mnemonic_record (file, record, new_insn);
else
break;
new_insn->processors))
{
/* only discard an instruction based in the processor
- model when both the instruction and the options are
- nonempty */
+ model when both the instruction and the options are
+ nonempty */
if (options.warn.discard)
notify (new_insn->line,
"Discarding instruction %s (processor-model)\n",
last = &(*last)->next;
*last = new_insn;
/* update global isa counters */
- isa->nr_insns ++;
+ isa->nr_insns++;
if (isa->max_nr_words < new_insn->nr_words)
isa->max_nr_words = new_insn->nr_words;
filter_add (&isa->flags, new_insn->flags);
}
break;
}
-
+
case define_record:
record = parse_macro_record (file, record);
break;
void
-print_insn_words (lf *file,
- insn_entry *insn)
+print_insn_words (lf *file, insn_entry * insn)
{
insn_word_entry *word = insn->words;
if (word != NULL)
if (options.insn_specifying_widths)
lf_printf (file, "%d.", field->width);
else
- lf_printf (file, "%d.", i2target (options.hi_bit_nr, field->first));
+ lf_printf (file, "%d.",
+ i2target (options.hi_bit_nr, field->first));
switch (field->type)
{
case insn_field_invalid:
}
}
}
+\f
-\f
void
function_entry_traverse (lf *file,
- function_entry *functions,
- function_entry_handler *handler,
- void *data)
+ function_entry * functions,
+ function_entry_handler * handler, void *data)
{
function_entry *function;
for (function = functions; function != NULL; function = function->next)
void
insn_table_traverse_insn (lf *file,
insn_table *isa,
- insn_entry_handler *handler,
- void *data)
+ insn_entry_handler * handler, void *data)
{
insn_entry *insn;
for (insn = isa->insns; insn != NULL; insn = insn->next)
handler (file, isa, insn, data);
}
}
-
\f
+
static void
dump_function_entry (lf *file,
- char *prefix,
- function_entry *entry,
- char *suffix)
+ char *prefix, function_entry * entry, char *suffix)
{
lf_printf (file, "%s(function_entry *) 0x%lx", prefix, (long) entry);
if (entry != NULL)
static void
dump_function_entries (lf *file,
- char *prefix,
- function_entry *entry,
- char *suffix)
+ char *prefix, function_entry * entry, char *suffix)
{
lf_printf (file, "%s", prefix);
lf_indent (file, +1);
{
switch (type)
{
- case scratch_value: return "scratch";
- case cache_value: return "cache";
- case compute_value: return "compute";
+ case scratch_value:
+ return "scratch";
+ case cache_value:
+ return "cache";
+ case compute_value:
+ return "compute";
}
ERROR ("Bad switch");
return 0;
}
static void
-dump_cache_entry (lf *file,
- char *prefix,
- cache_entry *entry,
- char *suffix)
+dump_cache_entry (lf *file, char *prefix, cache_entry *entry, char *suffix)
{
lf_printf (file, "%s(cache_entry *) 0x%lx", prefix, (long) entry);
if (entry != NULL)
{
dump_line_ref (file, "\n(line ", entry->line, ")");
dump_filter (file, "\n(flags ", entry->flags, ")");
- lf_printf (file, "\n(entry_type \"%s\")", cache_entry_type_to_str (entry->entry_type));
+ lf_printf (file, "\n(entry_type \"%s\")",
+ cache_entry_type_to_str (entry->entry_type));
lf_printf (file, "\n(name \"%s\")", entry->name);
dump_filter (file, "\n(original_fields ", entry->original_fields, ")");
lf_printf (file, "\n(type \"%s\")", entry->type);
}
void
-dump_cache_entries (lf *file,
- char *prefix,
- cache_entry *entry,
- char *suffix)
+dump_cache_entries (lf *file, char *prefix, cache_entry *entry, char *suffix)
{
lf_printf (file, "%s", prefix);
lf_indent (file, +1);
}
static void
-dump_model_data (lf *file,
- char *prefix,
- model_data *entry,
- char *suffix)
+dump_model_data (lf *file, char *prefix, model_data *entry, char *suffix)
{
lf_printf (file, "%s(model_data *) 0x%lx", prefix, (long) entry);
if (entry != NULL)
}
static void
-dump_model_datas (lf *file,
- char *prefix,
- model_data *entry,
- char *suffix)
+dump_model_datas (lf *file, char *prefix, model_data *entry, char *suffix)
{
lf_printf (file, "%s", prefix);
lf_indent (file, +1);
}
static void
-dump_model_entry (lf *file,
- char *prefix,
- model_entry *entry,
- char *suffix)
+dump_model_entry (lf *file, char *prefix, model_entry *entry, char *suffix)
{
lf_printf (file, "%s(model_entry *) 0x%lx", prefix, (long) entry);
if (entry != NULL)
}
static void
-dump_model_entries (lf *file,
- char *prefix,
- model_entry *entry,
- char *suffix)
+dump_model_entries (lf *file, char *prefix, model_entry *entry, char *suffix)
{
lf_printf (file, "%s", prefix);
lf_indent (file, +1);
static void
-dump_model_table (lf *file,
- char *prefix,
- model_table *entry,
- char *suffix)
+dump_model_table (lf *file, char *prefix, model_table *entry, char *suffix)
{
lf_printf (file, "%s(model_table *) 0x%lx", prefix, (long) entry);
if (entry != NULL)
{
switch (type)
{
- case insn_field_invalid: ASSERT (0); return "(invalid)";
- case insn_field_int: return "int";
- case insn_field_reserved: return "reserved";
- case insn_field_wild: return "wild";
- case insn_field_string: return "string";
+ case insn_field_invalid:
+ ASSERT (0);
+ return "(invalid)";
+ case insn_field_int:
+ return "int";
+ case insn_field_reserved:
+ return "reserved";
+ case insn_field_wild:
+ return "wild";
+ case insn_field_string:
+ return "string";
}
ERROR ("bad switch");
return 0;
void
dump_insn_field (lf *file,
- char *prefix,
- insn_field_entry *field,
- char *suffix)
+ char *prefix, insn_field_entry *field, char *suffix)
{
char *sep = " ";
lf_printf (file, "%s(insn_field_entry *) 0x%lx", prefix, (long) field);
lf_printf (file, "%s(first %d)", sep, field->first);
lf_printf (file, "%s(last %d)", sep, field->last);
lf_printf (file, "%s(width %d)", sep, field->width);
- lf_printf (file, "%s(type %s)", sep, insn_field_type_to_str (field->type));
+ lf_printf (file, "%s(type %s)", sep,
+ insn_field_type_to_str (field->type));
switch (field->type)
{
case insn_field_invalid:
void
dump_insn_word_entry (lf *file,
- char *prefix,
- insn_word_entry *word,
- char *suffix)
+ char *prefix, insn_word_entry *word, char *suffix)
{
lf_printf (file, "%s(insn_word_entry *) 0x%lx", prefix, (long) word);
if (word != NULL)
lf_printf (file, "\n(bit");
for (i = 0; i < options.insn_bit_size; i++)
lf_printf (file, "\n ((value %d) (mask %d) (field 0x%lx))",
- word->bit[i]->value, word->bit[i]->mask, (long) word->bit[i]->field);
+ word->bit[i]->value, word->bit[i]->mask,
+ (long) word->bit[i]->field);
lf_printf (file, ")");
for (field = word->first; field != NULL; field = field->next)
dump_insn_field (file, "\n(", field, ")");
static void
dump_insn_word_entries (lf *file,
- char *prefix,
- insn_word_entry *word,
- char *suffix)
+ char *prefix, insn_word_entry *word, char *suffix)
{
lf_printf (file, "%s", prefix);
while (word != NULL)
static void
dump_insn_model_entry (lf *file,
- char *prefix,
- insn_model_entry *model,
- char *suffix)
+ char *prefix, insn_model_entry *model, char *suffix)
{
lf_printf (file, "%s(insn_model_entry *) 0x%lx", prefix, (long) model);
if (model != NULL)
static void
dump_insn_model_entries (lf *file,
- char *prefix,
- insn_model_entry *model,
- char *suffix)
+ char *prefix, insn_model_entry *model, char *suffix)
{
lf_printf (file, "%s", prefix);
while (model != NULL)
static void
dump_insn_mnemonic_entry (lf *file,
char *prefix,
- insn_mnemonic_entry *mnemonic,
- char *suffix)
+ insn_mnemonic_entry *mnemonic, char *suffix)
{
- lf_printf (file, "%s(insn_mnemonic_entry *) 0x%lx", prefix, (long) mnemonic);
+ lf_printf (file, "%s(insn_mnemonic_entry *) 0x%lx", prefix,
+ (long) mnemonic);
if (mnemonic != NULL)
{
lf_indent (file, +1);
static void
dump_insn_mnemonic_entries (lf *file,
char *prefix,
- insn_mnemonic_entry *mnemonic,
- char *suffix)
+ insn_mnemonic_entry *mnemonic, char *suffix)
{
lf_printf (file, "%s", prefix);
while (mnemonic != NULL)
}
void
-dump_insn_entry (lf *file,
- char *prefix,
- insn_entry *entry,
- char *suffix)
+dump_insn_entry (lf *file, char *prefix, insn_entry * entry, char *suffix)
{
lf_printf (file, "%s(insn_entry *) 0x%lx", prefix, (long) entry);
if (entry != NULL)
lf_printf (file, " 0x%lx", (long) entry->model[i]);
lf_printf (file, ")");
dump_filter (file, "\n(processors ", entry->processors, ")");
- dump_insn_mnemonic_entries (file, "\n(mnemonics ", entry->mnemonics, ")");
+ dump_insn_mnemonic_entries (file, "\n(mnemonics ", entry->mnemonics,
+ ")");
dump_table_entry (file, "\n(code ", entry->code, ")");
lf_printf (file, "\n(next 0x%lx)", (long) entry->next);
lf_indent (file, -1);
- }
+ }
lf_printf (file, "%s", suffix);
}
static void
-dump_insn_entries (lf *file,
- char *prefix,
- insn_entry *entry,
- char *suffix)
+dump_insn_entries (lf *file, char *prefix, insn_entry * entry, char *suffix)
{
lf_printf (file, "%s", prefix);
lf_indent (file, +1);
void
-dump_insn_table (lf *file,
- char *prefix,
- insn_table *isa,
- char *suffix)
+dump_insn_table (lf *file, char *prefix, insn_table *isa, char *suffix)
{
lf_printf (file, "%s(insn_table *) 0x%lx", prefix, (long) isa);
if (isa != NULL)
*/
-enum {
+enum
+{
record_type_field = 1,
old_record_type_field = 2,
record_filter_flags_field = 2,
*/
-enum {
+enum
+{
include_filename_field = 4,
nr_include_fields,
};
;
- These update the global options structure. */
+ These update the global options structure. */
-enum {
+enum
+{
option_name_field = 4,
option_value_field,
nr_option_fields,
*/
-enum {
+enum
+{
macro_name_field = 4,
macro_args_field,
macro_expr_field,
*/
-enum {
+enum
+{
function_typedef_field = 4,
function_name_field,
function_param_field,
nr_function_fields,
};
-enum {
+enum
+{
function_model_name_field = 0,
nr_function_model_fields = 1,
};
-enum {
+enum
+{
old_function_typedef_field = 0,
old_function_type_field = 2,
old_function_name_field = 4,
old_function_param_field = 5,
- nr_old_function_fields = 5, /* parameter-list is optional */
+ nr_old_function_fields = 5, /* parameter-list is optional */
};
typedef struct _function_entry function_entry;
-struct _function_entry {
+struct _function_entry
+{
line_ref *line;
filter *flags;
filter *models;
typedef void function_entry_handler
-(lf *file,
- function_entry *function,
- void *data);
+ (lf *file, function_entry * function, void *data);
extern void function_entry_traverse
-(lf *file,
- function_entry *functions,
- function_entry_handler *handler,
- void *data);
+ (lf *file,
+ function_entry * functions, function_entry_handler * handler, void *data);
/* cache-macro:
*/
-enum {
+enum
+{
cache_typedef_field = 4,
cache_name_field,
cache_original_fields_field,
nr_cache_fields,
};
-typedef enum {
+typedef enum
+{
scratch_value,
cache_value,
compute_value,
-} cache_entry_type;
+}
+cache_entry_type;
typedef struct _cache_entry cache_entry;
-struct _cache_entry {
+struct _cache_entry
+{
line_ref *line;
filter *flags;
filter *models;
*/
-enum {
+enum
+{
nr_model_macro_fields = 4,
nr_model_data_fields = 4,
nr_model_static_fields = nr_function_fields,
};
typedef struct _model_data model_data;
-struct _model_data {
+struct _model_data
+{
line_ref *line;
filter *flags;
table_entry *entry;
model_data *next;
};
-enum {
+enum
+{
model_name_field = 4,
model_full_name_field,
model_unit_data_field,
};
typedef struct _model_entry model_entry;
-struct _model_entry {
+struct _model_entry
+{
line_ref *line;
filter *flags;
char *name;
typedef struct _model_table model_table;
-struct _model_table {
+struct _model_table
+{
filter *processors;
int nr_models;
model_entry *models;
*/
-typedef enum _insn_field_cond_type {
+typedef enum _insn_field_cond_type
+{
insn_field_cond_value,
insn_field_cond_field,
-} insn_field_cond_type;
-typedef enum _insn_field_cond_test {
+}
+insn_field_cond_type;
+typedef enum _insn_field_cond_test
+{
insn_field_cond_eq,
insn_field_cond_ne,
-} insn_field_cond_test;
+}
+insn_field_cond_test;
typedef struct _insn_field_cond insn_field_cond;
-struct _insn_field_cond {
+struct _insn_field_cond
+{
insn_field_cond_type type;
insn_field_cond_test test;
insn_uint value;
};
-typedef enum _insn_field_type {
+typedef enum _insn_field_type
+{
insn_field_invalid,
insn_field_int,
insn_field_reserved,
insn_field_wild,
insn_field_string,
-} insn_field_type;
+}
+insn_field_type;
typedef struct _insn_field_entry insn_field_entry;
-struct _insn_field_entry {
+struct _insn_field_entry
+{
int first;
int last;
int width;
};
typedef struct _insn_bit_entry insn_bit_entry;
-struct _insn_bit_entry {
+struct _insn_bit_entry
+{
int value;
int mask;
insn_field_entry *field;
-typedef struct _insn_entry insn_entry; /* forward */
+typedef struct _insn_entry insn_entry; /* forward */
typedef struct _insn_word_entry insn_word_entry;
-struct _insn_word_entry {
+struct _insn_word_entry
+{
/* list of sub-fields making up the instruction. bit provides
faster access to the field data for bit N. */
insn_field_entry *first;
*/
-enum {
+enum
+{
insn_model_name_field = 0,
insn_model_unit_data_field = 1,
nr_insn_model_fields = 1,
};
typedef struct _insn_model_entry insn_model_entry;
-struct _insn_model_entry {
+struct _insn_model_entry
+{
line_ref *line;
insn_entry *insn;
filter *names;
*/
-enum {
+enum
+{
insn_mnemonic_format_field = 0,
insn_mnemonic_condition_field = 1,
nr_insn_mnemonic_fields = 1,
};
typedef struct _insn_mnemonic_entry insn_mnemonic_entry;
-struct _insn_mnemonic_entry {
+struct _insn_mnemonic_entry
+{
line_ref *line;
insn_entry *insn;
char *format;
*/
-enum {
+enum
+{
insn_word_field = 0,
insn_format_name_field = 1,
insn_filter_flags_field = 2,
/* typedef struct _insn_entry insn_entry; */
-struct _insn_entry {
+struct _insn_entry
+{
line_ref *line;
- filter *flags; /* filtered by options.filters */
+ filter *flags; /* filtered by options.filters */
char *format_name;
filter *options;
char *name;
*/
typedef struct _insn_table insn_table;
-struct _insn_table {
+struct _insn_table
+{
cache_entry *caches;
int max_nr_words;
int nr_insns;
filter *flags;
};
-extern insn_table *load_insn_table
-(char *file_name,
- cache_entry *cache);
+extern insn_table *load_insn_table (char *file_name, cache_entry *cache);
typedef void insn_entry_handler
-(lf *file,
- insn_table *isa,
- insn_entry *insn,
- void *data);
+ (lf *file, insn_table *isa, insn_entry * insn, void *data);
extern void insn_table_traverse_insn
-(lf *file,
- insn_table *isa,
- insn_entry_handler *handler,
- void *data);
+ (lf *file, insn_table *isa, insn_entry_handler * handler, void *data);
/* Printing */
-extern void print_insn_words
-(lf *file,
- insn_entry *insn);
+extern void print_insn_words (lf *file, insn_entry * insn);
/* Debugging */
void
-dump_insn_field
-(lf *file,
- char *prefix,
- insn_field_entry *field,
- char *suffix);
+ dump_insn_field
+ (lf *file, char *prefix, insn_field_entry *field, char *suffix);
void
-dump_insn_word_entry
-(lf *file,
- char *prefix,
- insn_word_entry *word,
- char *suffix);
+ dump_insn_word_entry
+ (lf *file, char *prefix, insn_word_entry *word, char *suffix);
void
-dump_insn_entry
-(lf *file,
- char *prefix,
- insn_entry *insn,
- char *suffix);
+ dump_insn_entry (lf *file, char *prefix, insn_entry * insn, char *suffix);
void
-dump_cache_entries
-(lf *file,
- char *prefix,
- cache_entry *entry,
- char *suffix);
+ dump_cache_entries
+ (lf *file, char *prefix, cache_entry *entry, char *suffix);
-void
-dump_insn_table
-(lf *file,
- char *prefix,
- insn_table *isa,
- char *suffix);
+void dump_insn_table (lf *file, char *prefix, insn_table *isa, char *suffix);
#endif
#endif
-struct _lf {
+struct _lf
+{
FILE *stream;
- int line_nr; /* nr complete lines written, curr line is line_nr+1 */
+ int line_nr; /* nr complete lines written, curr line is line_nr+1 */
int indent;
int line_blank;
const char *name;
lf_open (char *name,
char *real_name,
lf_file_references references,
- lf_file_type type,
- const char *program)
+ lf_file_type type, const char *program)
{
/* create a file object */
- lf *new_lf = ZALLOC(lf);
+ lf *new_lf = ZALLOC (lf);
ASSERT (new_lf != NULL);
new_lf->references = references;
new_lf->type = type;
new_lf->name = (real_name == NULL ? name : real_name);
new_lf->program = program;
/* attach to stdout if pipe */
- if (!strcmp(name, "-")) {
- new_lf->stream = stdout;
- }
- else {
- /* create a new file */
- new_lf->stream = fopen(name, "w");
- if (new_lf->stream == NULL) {
- perror(name);
- exit(1);
+ if (!strcmp (name, "-"))
+ {
+ new_lf->stream = stdout;
+ }
+ else
+ {
+ /* create a new file */
+ new_lf->stream = fopen (name, "w");
+ if (new_lf->stream == NULL)
+ {
+ perror (name);
+ exit (1);
+ }
}
- }
return new_lf;
}
void
-lf_close(lf *file)
+lf_close (lf *file)
{
- if (file->stream != stdout) {
- if (fclose(file->stream)) {
- perror("lf_close.fclose");
- exit(1);
+ if (file->stream != stdout)
+ {
+ if (fclose (file->stream))
+ {
+ perror ("lf_close.fclose");
+ exit (1);
+ }
+ free (file);
}
- free(file);
- }
}
int
-lf_putchr(lf *file,
- const char chr)
+lf_putchr (lf *file, const char chr)
{
int nr = 0;
- if (chr == '\n') {
- file->line_nr += 1;
- file->line_blank = 1;
- }
- else if (file->line_blank) {
- int pad;
- for (pad = file->indent; pad > 0; pad--)
- putc(' ', file->stream);
- nr += file->indent;
- file->line_blank = 0;
- }
- putc(chr, file->stream);
+ if (chr == '\n')
+ {
+ file->line_nr += 1;
+ file->line_blank = 1;
+ }
+ else if (file->line_blank)
+ {
+ int pad;
+ for (pad = file->indent; pad > 0; pad--)
+ putc (' ', file->stream);
+ nr += file->indent;
+ file->line_blank = 0;
+ }
+ putc (chr, file->stream);
nr += 1;
return nr;
}
int
-lf_write (lf *file,
- const char *string,
- int strlen_string)
+lf_write (lf *file, const char *string, int strlen_string)
{
int nr = 0;
int i;
void
-lf_indent_suppress(lf *file)
+lf_indent_suppress (lf *file)
{
file->line_blank = 0;
}
int
-lf_putstr(lf *file,
- const char *string)
+lf_putstr (lf *file, const char *string)
{
int nr = 0;
const char *chp;
- if (string != NULL) {
- for (chp = string; *chp != '\0'; chp++) {
- nr += lf_putchr(file, *chp);
+ if (string != NULL)
+ {
+ for (chp = string; *chp != '\0'; chp++)
+ {
+ nr += lf_putchr (file, *chp);
+ }
}
- }
return nr;
}
static int
-do_lf_putunsigned(lf *file,
- unsigned u)
+do_lf_putunsigned (lf *file, unsigned u)
{
int nr = 0;
- if (u > 0) {
- nr += do_lf_putunsigned(file, u / 10);
- nr += lf_putchr(file, (u % 10) + '0');
- }
+ if (u > 0)
+ {
+ nr += do_lf_putunsigned (file, u / 10);
+ nr += lf_putchr (file, (u % 10) + '0');
+ }
return nr;
}
int
-lf_putint(lf *file,
- int decimal)
+lf_putint (lf *file, int decimal)
{
int nr = 0;
if (decimal == 0)
- nr += lf_putchr(file, '0');
- else if (decimal < 0) {
- nr += lf_putchr(file, '-');
- nr += do_lf_putunsigned(file, -decimal);
- }
- else if (decimal > 0) {
- nr += do_lf_putunsigned(file, decimal);
- }
+ nr += lf_putchr (file, '0');
+ else if (decimal < 0)
+ {
+ nr += lf_putchr (file, '-');
+ nr += do_lf_putunsigned (file, -decimal);
+ }
+ else if (decimal > 0)
+ {
+ nr += do_lf_putunsigned (file, decimal);
+ }
else
- ASSERT(0);
+ ASSERT (0);
return nr;
}
int
-lf_printf (lf *file,
- const char *fmt,
- ...)
+lf_printf (lf *file, const char *fmt, ...)
{
int nr = 0;
char buf[1024];
/* FIXME - this is really stuffed but so is vsprintf() on a sun! */
ASSERT (strlen (buf) < sizeof (buf));
nr += lf_putstr (file, buf);
- va_end(ap);
+ va_end (ap);
return nr;
}
int
-lf_print__line_ref (lf *file,
- line_ref *line)
+lf_print__line_ref (lf *file, line_ref *line)
{
return lf_print__external_ref (file, line->line_nr, line->file_name);
}
int
-lf_print__external_ref (lf *file,
- int line_nr,
- const char *file_name)
+lf_print__external_ref (lf *file, int line_nr, const char *file_name)
{
int nr = 0;
switch (file->references)
{
case lf_include_references:
- lf_indent_suppress(file);
+ lf_indent_suppress (file);
nr += lf_putstr (file, "#line ");
nr += lf_putint (file, line_nr);
nr += lf_putstr (file, " \"");
lf_print__internal_ref (lf *file)
{
int nr = 0;
- nr += lf_print__external_ref (file, file->line_nr+2, file->name);
+ nr += lf_print__external_ref (file, file->line_nr + 2, file->name);
/* line_nr == last_line, want to number from next */
return nr;
}
lf_print__gnu_copyleft (lf *file)
{
int nr = 0;
- switch (file->type) {
- case lf_is_c:
- case lf_is_h:
- nr += lf_printf(file, "\
+ switch (file->type)
+ {
+ case lf_is_c:
+ case lf_is_h:
+ nr += lf_printf (file, "\
/* This file is part of GDB.\n\
\n\
Copyright 2002 Free Software Foundation, Inc.\n\
--\n\
\n\
This file was generated by the program %s */\n\
-", filter_filename(file->program));
- break;
- default:
- ASSERT(0);
- break;
- }
+", filter_filename (file->program));
+ break;
+ default:
+ ASSERT (0);
+ break;
+ }
return nr;
}
int
-lf_putbin(lf *file, int decimal, int width)
+lf_putbin (lf *file, int decimal, int width)
{
int nr = 0;
int bit;
- ASSERT(width > 0);
- for (bit = 1 << (width-1); bit != 0; bit >>= 1) {
- if (decimal & bit)
- nr += lf_putchr(file, '1');
- else
- nr += lf_putchr(file, '0');
- }
+ ASSERT (width > 0);
+ for (bit = 1 << (width - 1); bit != 0; bit >>= 1)
+ {
+ if (decimal & bit)
+ nr += lf_putchr (file, '1');
+ else
+ nr += lf_putchr (file, '0');
+ }
return nr;
}
int
-lf_print__this_file_is_empty(lf *file,
- const char *reason)
+lf_print__this_file_is_empty (lf *file, const char *reason)
{
int nr = 0;
- switch (file->type) {
- case lf_is_c:
- case lf_is_h:
- nr += lf_printf (file,
- "/* This generated file (%s) is intentionally left blank",
- file->name);
- if (reason != NULL)
- nr += lf_printf (file, " - %s", reason);
- nr += lf_printf (file, " */\n");
- break;
- default:
- ERROR ("Bad switch");
- }
+ switch (file->type)
+ {
+ case lf_is_c:
+ case lf_is_h:
+ nr += lf_printf (file,
+ "/* This generated file (%s) is intentionally left blank",
+ file->name);
+ if (reason != NULL)
+ nr += lf_printf (file, " - %s", reason);
+ nr += lf_printf (file, " */\n");
+ break;
+ default:
+ ERROR ("Bad switch");
+ }
return nr;
}
int
-lf_print__ucase_filename(lf *file)
+lf_print__ucase_filename (lf *file)
{
int nr = 0;
const char *chp = file->name;
- while (*chp != '\0') {
- char ch = *chp;
- if (islower(ch)) {
- nr += lf_putchr(file, toupper(ch));
+ while (*chp != '\0')
+ {
+ char ch = *chp;
+ if (islower (ch))
+ {
+ nr += lf_putchr (file, toupper (ch));
+ }
+ else if (ch == '.')
+ nr += lf_putchr (file, '_');
+ else
+ nr += lf_putchr (file, ch);
+ chp++;
}
- else if (ch == '.')
- nr += lf_putchr(file, '_');
- else
- nr += lf_putchr(file, ch);
- chp++;
- }
return nr;
}
int
-lf_print__file_start(lf *file)
+lf_print__file_start (lf *file)
{
int nr = 0;
- switch (file->type) {
- case lf_is_h:
- case lf_is_c:
- nr += lf_print__gnu_copyleft(file);
- nr += lf_printf(file, "\n");
- nr += lf_printf(file, "#ifndef ");
- nr += lf_print__ucase_filename(file);
- nr += lf_printf(file, "\n");
- nr += lf_printf(file, "#define ");
- nr += lf_print__ucase_filename(file);
- nr += lf_printf(file, "\n");
- nr += lf_printf(file, "\n");
- break;
- default:
- ASSERT(0);
- }
+ switch (file->type)
+ {
+ case lf_is_h:
+ case lf_is_c:
+ nr += lf_print__gnu_copyleft (file);
+ nr += lf_printf (file, "\n");
+ nr += lf_printf (file, "#ifndef ");
+ nr += lf_print__ucase_filename (file);
+ nr += lf_printf (file, "\n");
+ nr += lf_printf (file, "#define ");
+ nr += lf_print__ucase_filename (file);
+ nr += lf_printf (file, "\n");
+ nr += lf_printf (file, "\n");
+ break;
+ default:
+ ASSERT (0);
+ }
return nr;
}
int
-lf_print__file_finish(lf *file)
+lf_print__file_finish (lf *file)
{
int nr = 0;
- switch (file->type) {
- case lf_is_h:
- case lf_is_c:
- nr += lf_printf(file, "\n");
- nr += lf_printf(file, "#endif /* _");
- nr += lf_print__ucase_filename(file);
- nr += lf_printf(file, "_*/\n");
- break;
- default:
- ASSERT(0);
- }
+ switch (file->type)
+ {
+ case lf_is_h:
+ case lf_is_c:
+ nr += lf_printf (file, "\n");
+ nr += lf_printf (file, "#endif /* _");
+ nr += lf_print__ucase_filename (file);
+ nr += lf_printf (file, "_*/\n");
+ break;
+ default:
+ ASSERT (0);
+ }
return nr;
}
int
lf_print__function_type (lf *file,
const char *type,
- const char *prefix,
- const char *trailing_space)
+ const char *prefix, const char *trailing_space)
{
int nr = 0;
nr += lf_printf (file, "%s\\\n(%s)", prefix, type);
int
lf_print__function_type_function (lf *file,
- print_function *print_type,
+ print_function * print_type,
const char *prefix,
const char *trailing_space)
{
nr += lf_printf (file, "%s", trailing_space);
return nr;
}
-
typedef struct _lf lf;
-typedef enum {
+typedef enum
+{
lf_is_h,
lf_is_c,
lf_is_text,
-} lf_file_type;
+}
+lf_file_type;
-typedef enum {
+typedef enum
+{
lf_include_references,
lf_omit_references,
-} lf_file_references;
+}
+lf_file_references;
/* Open the file NAME for writing ("-" for stdout). Use REAL_NAME
the print messages below. */
extern lf *lf_open
-(char *name,
- char *real_name,
- lf_file_references file_references,
- lf_file_type type,
- const char *program);
+ (char *name,
+ char *real_name,
+ lf_file_references file_references,
+ lf_file_type type, const char *program);
-extern void lf_close
-(lf *file);
+extern void lf_close (lf *file);
/* Basic output functions */
-extern int lf_write
-(lf *file,
- const char *string,
- int len);
+extern int lf_write (lf *file, const char *string, int len);
-extern int lf_putchr
-(lf *file,
- const char ch);
+extern int lf_putchr (lf *file, const char ch);
-extern int lf_putstr
-(lf *file,
- const char *string);
+extern int lf_putstr (lf *file, const char *string);
-extern int lf_putint
-(lf *file,
- int decimal);
+extern int lf_putint (lf *file, int decimal);
-extern int lf_putbin
-(lf *file,
- int decimal,
- int width);
+extern int lf_putbin (lf *file, int decimal, int width);
extern int lf_printf
-(lf *file,
- const char *fmt,
- ...) __attribute__((format(printf, 2, 3)));
+ (lf *file, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
/* Indentation control.
lf_indent_suppress suppresses indentation on the next line (current
line if that has not yet been started) */
-extern void lf_indent_suppress
-(lf *file);
+extern void lf_indent_suppress (lf *file);
-extern void lf_indent
-(lf *file,
- int delta);
+extern void lf_indent (lf *file, int delta);
/* Print generic text: */
-extern int lf_print__gnu_copyleft
-(lf *file);
+extern int lf_print__gnu_copyleft (lf *file);
-extern int lf_print__file_start
-(lf *file);
+extern int lf_print__file_start (lf *file);
-extern int lf_print__this_file_is_empty
-(lf *file,
- const char *reason);
+extern int lf_print__this_file_is_empty (lf *file, const char *reason);
-extern int lf_print__file_finish
-(lf *file);
+extern int lf_print__file_finish (lf *file);
-extern int lf_print__internal_ref
-(lf *file);
+extern int lf_print__internal_ref (lf *file);
extern int lf_print__external_ref
-(lf *file,
- int line_nr,
- const char *file_name);
+ (lf *file, int line_nr, const char *file_name);
-extern int lf_print__line_ref
-(lf *file,
- line_ref *line);
+extern int lf_print__line_ref (lf *file, line_ref *line);
-extern int lf_print__ucase_filename
-(lf *file);
+extern int lf_print__ucase_filename (lf *file);
extern int lf_print__function_type
-(lf *file,
- const char *type,
- const char *prefix,
- const char *trailing_space);
+ (lf *file,
+ const char *type, const char *prefix, const char *trailing_space);
-typedef int print_function(lf *file);
+typedef int print_function (lf *file);
extern int lf_print__function_type_function
-(lf *file,
- print_function *print_type,
- const char *prefix,
- const char *trailing_space);
-
+ (lf *file,
+ print_function * print_type,
+ const char *prefix, const char *trailing_space);
trailing '\n' */
void
-error (const line_ref *line,
- char *msg,
- ...)
+error (const line_ref *line, char *msg, ...)
{
va_list ap;
if (line != NULL)
}
void
-warning (const line_ref *line,
- char *msg,
- ...)
+warning (const line_ref *line, char *msg, ...)
{
va_list ap;
if (line != NULL)
}
void
-notify (const line_ref *line,
- char *msg,
- ...)
+notify (const line_ref *line, char *msg, ...)
{
va_list ap;
if (line != NULL)
fprintf (stdout, "%s %d: info: ", line->file_name, line->line_nr);
- va_start(ap, msg);
+ va_start (ap, msg);
vfprintf (stdout, msg, ap);
- va_end(ap);
+ va_end (ap);
}
void *
-zalloc(long size)
+zalloc (long size)
{
- void *memory = malloc(size);
+ void *memory = malloc (size);
if (memory == NULL)
ERROR ("zalloc failed");
- memset(memory, 0, size);
+ memset (memory, 0, size);
return memory;
}
int base = 10;
unsigned long long num = 0;
int looping;
-
+
while (isspace (*a))
a++;
-
- if (strcmp (a, "true") == 0
- || strcmp (a, "TRUE") == 0)
+
+ if (strcmp (a, "true") == 0 || strcmp (a, "TRUE") == 0)
return 1;
- if (strcmp (a, "false") == 0
- || strcmp (a, "false") == 0)
+ if (strcmp (a, "false") == 0 || strcmp (a, "false") == 0)
return 0;
if (*a == '-')
neg = 1;
a++;
}
-
+
if (*a == '0')
{
if (a[1] == 'x' || a[1] == 'X')
else
base = 8;
}
-
+
looping = 1;
while (looping)
{
int ch = *a++;
-
+
switch (base)
{
default:
looping = 0;
break;
-
+
case 2:
if (ch >= '0' && ch <= '1')
{
looping = 0;
}
break;
-
+
case 10:
if (ch >= '0' && ch <= '9')
{
looping = 0;
}
break;
-
+
case 8:
if (ch >= '0' && ch <= '7')
{
looping = 0;
}
break;
-
+
case 16:
if (ch >= '0' && ch <= '9')
{
break;
}
}
-
+
if (neg)
- num = - num;
+ num = -num;
return num;
}
unsigned
-target_a2i(int ms_bit_nr,
- const char *a)
+target_a2i (int ms_bit_nr, const char *a)
{
if (ms_bit_nr)
- return (ms_bit_nr - a2i(a));
+ return (ms_bit_nr - a2i (a));
else
- return a2i(a);
+ return a2i (a);
}
unsigned
-i2target(int ms_bit_nr,
- unsigned bit)
+i2target (int ms_bit_nr, unsigned bit)
{
if (ms_bit_nr)
return ms_bit_nr - bit;
int
-name2i (const char *names,
- const name_map *map)
+name2i (const char *names, const name_map * map)
{
const name_map *curr;
const char *name = names;
while (*name != '\0')
{
/* find our name */
- char *end = strchr(name, ',');
+ char *end = strchr (name, ',');
char *next;
unsigned len;
if (end == NULL)
{
- end = strchr(name, '\0');
+ end = strchr (name, '\0');
next = end;
}
else
}
const char *
-i2name (const int i,
- const name_map *map)
+i2name (const int i, const name_map * map)
{
while (map->name != NULL)
{
#include "config.h"
-enum {
+enum
+{
default_insn_bit_size = 32,
max_insn_bit_size = 64,
};
typedef long long signed64;
typedef unsigned long long unsigned64;
-#else /* _WIN32 */
+#else /* _WIN32 */
typedef __int64 signed64;
typedef unsigned __int64 unsigned64;
#include "filter_host.h"
typedef struct _line_ref line_ref;
-struct _line_ref {
+struct _line_ref
+{
const char *file_name;
int line_nr;
};
/* Error appends a new line, warning and notify do not */
-typedef void error_func
-(const line_ref *line,
- char *msg,
- ...);
+typedef void error_func (const line_ref *line, char *msg, ...);
extern error_func error;
extern error_func warning;
#define STRNDUP(STRING,LEN) (strncpy (zalloc ((LEN) + 1), (STRING), (LEN)))
#endif
-extern void *zalloc
-(long size);
+extern void *zalloc (long size);
-extern unsigned target_a2i
-(int ms_bit_nr,
- const char *a);
+extern unsigned target_a2i (int ms_bit_nr, const char *a);
-extern unsigned i2target
-(int ms_bit_nr,
- unsigned bit);
+extern unsigned i2target (int ms_bit_nr, unsigned bit);
-extern unsigned long long a2i
-(const char *a);
+extern unsigned long long a2i (const char *a);
/* Try looking for name in the map table (returning the corresponding
If the the sentinal (NAME == NULL) its value if >= zero is returned
as the default. */
-typedef struct _name_map {
+typedef struct _name_map
+{
const char *name;
int i;
-} name_map;
+}
+name_map;
-extern int name2i
-(const char *name,
- const name_map *map);
+extern int name2i (const char *name, const name_map * map);
-extern const char *i2name
-(const int i,
- const name_map *map);
+extern const char *i2name (const int i, const name_map * map);
#endif
typedef struct _open_table open_table;
-struct _open_table {
+struct _open_table
+{
size_t size;
char *buffer;
char *pos;
open_table *parent;
table *root;
};
-struct _table {
+struct _table
+{
open_table *current;
};
static line_ref *
-current_line (open_table *file)
+current_line (open_table * file)
{
line_ref *entry = ZALLOC (line_ref);
*entry = file->pseudo_line;
}
static table_entry *
-new_table_entry (open_table *file,
- table_entry_type type)
+new_table_entry (open_table * file, table_entry_type type)
{
table_entry *entry;
entry = ZALLOC (table_entry);
}
static void
-set_nr_table_entry_fields (table_entry *entry,
- int nr_fields)
+set_nr_table_entry_fields (table_entry *entry, int nr_fields)
{
- entry->field = NZALLOC (char*, nr_fields + 1);
+ entry->field = NZALLOC (char *, nr_fields + 1);
entry->nr_fields = nr_fields;
}
void
table_push (table *root,
- line_ref *line,
- table_include *includes,
- const char *file_name)
+ line_ref *line, table_include *includes, const char *file_name)
{
FILE *ff;
open_table *file;
while (1)
{
/* save the file name */
- char *dup_name = NZALLOC (char, strlen (include->dir) + strlen (file_name) + 2);
+ char *dup_name =
+ NZALLOC (char, strlen (include->dir) + strlen (file_name) + 2);
if (dup_name == NULL)
{
perror (file_name);
exit (1);
}
include = include->next;
- }
+ }
/* determine the size */
fseek (ff, 0, SEEK_SET);
/* allocate this much memory */
- file->buffer = (char*) zalloc (file->size + 1);
+ file->buffer = (char *) zalloc (file->size + 1);
if (file->buffer == NULL)
{
perror (file_name);
file->pos = file->buffer;
/* read it all in */
- if (fread (file->buffer, 1, file->size, ff) < file->size) {
- perror (file_name);
- exit (1);
- }
+ if (fread (file->buffer, 1, file->size, ff) < file->size)
+ {
+ perror (file_name);
+ exit (1);
+ }
file->buffer[file->size] = '\0';
/* set the initial line numbering */
- file->real_line.line_nr = 1; /* specifies current line */
- file->pseudo_line.line_nr = 1; /* specifies current line */
+ file->real_line.line_nr = 1; /* specifies current line */
+ file->pseudo_line.line_nr = 1; /* specifies current line */
/* done */
fclose (ff);
{
while (1)
{
- if (*chp == '\0'
- || *chp == '\n'
- || !isspace (*chp))
+ if (*chp == '\0' || *chp == '\n' || !isspace (*chp))
return chp;
chp++;
}
{
while (1)
{
- if (chp <= start
- || !isspace (chp[-1]))
+ if (chp <= start || !isspace (chp[-1]))
return chp;
chp--;
}
{
while (1)
{
- if (*chp == '\0'
- || *chp == '\n'
- || !isdigit (*chp))
+ if (*chp == '\0' || *chp == '\n' || !isdigit (*chp))
return chp;
chp++;
}
}
char *
-skip_to_separator (char *chp,
- char *separators)
+skip_to_separator (char *chp, char *separators)
{
while (1)
{
static char *
-skip_to_nl (char * chp)
+skip_to_nl (char *chp)
{
return skip_to_separator (chp, "\n");
}
static void
-next_line (open_table *file)
+next_line (open_table * file)
{
file->pos = skip_to_nl (file->pos);
if (*file->pos == '0')
{
open_table *file = root->current;
table_entry *entry = NULL;
- while(1)
+ while (1)
{
/* end-of-file? */
if (*file->pos == '{')
{
char *chp;
- next_line (file); /* discard leading brace */
+ next_line (file); /* discard leading brace */
entry = new_table_entry (file, table_code_entry);
chp = file->pos;
/* determine how many lines are involved - look for <nl> "}" */
if (*chp == '\t')
entry->field[line_nr] = chp + 1;
else
- entry->field[line_nr] = ""; /* blank */
+ entry->field[line_nr] = ""; /* blank */
chp = skip_to_null (chp) + 1;
}
}
char *file_name;
file->pos = chp;
/* parse the number */
- line_nr = atoi(file->pos) - 1;
+ line_nr = atoi (file->pos) - 1;
/* skip to the file name */
while (file->pos[0] != '0'
- && file->pos[0] != '"'
- && file->pos[0] != '\0')
+ && file->pos[0] != '"' && file->pos[0] != '\0')
file->pos++;
if (file->pos[0] != '"')
- error (&file->real_line, "Missing opening quote in cpp directive\n");
+ error (&file->real_line,
+ "Missing opening quote in cpp directive\n");
/* parse the file name */
file->pos++;
file_name = file->pos;
- while (file->pos[0] != '"'
- && file->pos[0] != '\0')
+ while (file->pos[0] != '"' && file->pos[0] != '\0')
file->pos++;
if (file->pos[0] != '"')
- error (&file->real_line, "Missing closing quote in cpp directive\n");
+ error (&file->real_line,
+ "Missing closing quote in cpp directive\n");
file->pos[0] = '\0';
file->pos++;
file->pos = skip_to_nl (file->pos);
if (file->pos[0] != '\n')
- error (&file->real_line, "Missing newline in cpp directive\n");
+ error (&file->real_line,
+ "Missing newline in cpp directive\n");
file->pseudo_line.file_name = file_name;
file->pseudo_line.line_nr = line_nr;
next_line (file);
}
extern void
-table_print_code (lf *file,
- table_entry *entry)
+table_print_code (lf *file, table_entry *entry)
{
int field_nr;
int nr = 0;
- for (field_nr = 0;
- field_nr < entry->nr_fields;
- field_nr++)
+ for (field_nr = 0; field_nr < entry->nr_fields; field_nr++)
{
char *chp = entry->field[field_nr];
int in_bit_field = 0;
if (*chp == '#')
- lf_indent_suppress(file);
- while (*chp != '\0')
+ lf_indent_suppress (file);
+ while (*chp != '\0')
{
- if (chp[0] == '{'
- && !isspace(chp[1])
- && chp[1] != '\0')
+ if (chp[0] == '{' && !isspace (chp[1]) && chp[1] != '\0')
{
in_bit_field = 1;
- nr += lf_putchr(file, '_');
+ nr += lf_putchr (file, '_');
}
else if (in_bit_field && chp[0] == ':')
{
- nr += lf_putchr(file, '_');
+ nr += lf_putchr (file, '_');
}
else if (in_bit_field && *chp == '}')
{
- nr += lf_putchr(file, '_');
+ nr += lf_putchr (file, '_');
in_bit_field = 0;
}
- else
+ else
{
- nr += lf_putchr(file, *chp);
+ nr += lf_putchr (file, *chp);
}
chp++;
}
line.line_nr += field_nr;
error (&line, "Bit field brace miss match\n");
}
- nr += lf_putchr(file, '\n');
+ nr += lf_putchr (file, '\n');
}
}
void
-dump_line_ref (lf *file,
- char *prefix,
- const line_ref *line,
- char *suffix)
+dump_line_ref (lf *file, char *prefix, const line_ref *line, char *suffix)
{
lf_printf (file, "%s(line_ref*) 0x%lx", prefix, (long) line);
if (line != NULL)
{
switch (type)
{
- case table_code_entry: return "code-entry";
- case table_colon_entry: return "colon-entry";
+ case table_code_entry:
+ return "code-entry";
+ case table_colon_entry:
+ return "colon-entry";
}
return "*invalid*";
}
void
-dump_table_entry(lf *file,
- char *prefix,
- const table_entry *entry,
- char *suffix)
+dump_table_entry (lf *file,
+ char *prefix, const table_entry *entry, char *suffix)
{
lf_printf (file, "%s(table_entry*) 0x%lx", prefix, (long) entry);
if (entry != NULL)
#ifdef MAIN
int
-main(int argc, char **argv)
+main (int argc, char **argv)
{
table *t;
table_entry *entry;
if (argc != 2)
{
- printf("Usage: table <file>\n");
+ printf ("Usage: table <file>\n");
exit (1);
}
{
char line[10];
entry = table_read (t);
- line_nr ++;
+ line_nr++;
sprintf (line, "(%d ", line_nr);
dump_table_entry (l, line, entry, ")\n");
}
typedef struct _table table;
-typedef enum {
+typedef enum
+{
table_colon_entry,
table_code_entry,
-} table_entry_type;
+}
+table_entry_type;
typedef struct _table_entry table_entry;
-struct _table_entry {
+struct _table_entry
+{
table *file;
line_ref *line;
table_entry_type type;
/* List of directories to search when opening a pushed file. Current
directory is always searched first */
typedef struct _table_include table_include;
-struct _table_include {
+struct _table_include
+{
char *dir;
table_include *next;
};
/* Open/read a table file. Since the file is read once during open
(and then closed immediatly) there is no close method. */
-extern table *table_open
-(const char *file_name);
+extern table *table_open (const char *file_name);
-extern table_entry *table_read
-(table *file);
+extern table_entry *table_read (table *file);
/* Push the the state of the current file and open FILE_NAME. When
the end of FILE_NAME is reached, return to the pushed file */
extern void table_push
-(table *file,
- line_ref *line,
- table_include *search,
- const char *file_name);
+ (table *file, line_ref *line, table_include *search, const char *file_name);
/* Expand the specified field_nr using the internal expansion table.
A field is only expanded when explicitly specified. */
-extern void table_expand_field
-(table_entry *entry,
- int field_nr);
+extern void table_expand_field (table_entry *entry, int field_nr);
/* Given a code entry, write the code to FILE. Since any
leading/trailing braces were striped as part of the read, they are
not written. */
-extern void table_print_code
-(lf *file,
- table_entry *entry);
+extern void table_print_code (lf *file, table_entry *entry);
/* Debugging */
extern void dump_line_ref
-(lf *file,
- char *prefix,
- const line_ref *line,
- char *suffix);
+ (lf *file, char *prefix, const line_ref *line, char *suffix);
extern void dump_table_entry
-(lf *file,
- char *prefix,
- const table_entry *entry,
- char *suffix);
+ (lf *file, char *prefix, const table_entry *entry, char *suffix);
/* Utilities for skipping around text */
-extern char *skip_digits
-(char *chp);
+extern char *skip_digits (char *chp);
-extern char *skip_spaces
-(char *chp);
+extern char *skip_spaces (char *chp);
-extern char *skip_to_separator
-(char *chp,
- char *separators);
+extern char *skip_to_separator (char *chp, char *separators);
-extern char *back_spaces
-(char *start,
- char *chp);
+extern char *back_spaces (char *start, char *chp);
projects / binutils-gdb.git / commitdiff