From 4e0bf4c4d00096ac436378edaf7718dafec9ff82 Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Fri, 22 Nov 2002 04:20:49 +0000 Subject: [PATCH] 2002-11-21 Andrew Cagney * 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. --- sim/igen/ChangeLog | 12 + sim/igen/filter.c | 153 ++++--- sim/igen/filter.h | 34 +- sim/igen/filter_host.h | 3 +- sim/igen/gen-engine.c | 244 +++++------ sim/igen/gen-engine.h | 15 +- sim/igen/gen-icache.c | 482 ++++++++++----------- sim/igen/gen-icache.h | 50 ++- sim/igen/gen-idecode.c | 475 +++++++++------------ sim/igen/gen-idecode.h | 23 +- sim/igen/gen-itable.c | 89 ++-- sim/igen/gen-itable.h | 8 +- sim/igen/gen-model.c | 625 +++++++++++++++------------- sim/igen/gen-model.h | 8 +- sim/igen/gen-semantics.c | 130 +++--- sim/igen/gen-semantics.h | 36 +- sim/igen/gen-support.c | 136 +++--- sim/igen/gen-support.h | 9 +- sim/igen/gen.c | 731 +++++++++++++++----------------- sim/igen/gen.h | 118 +++--- sim/igen/igen.c | 485 ++++++++++++---------- sim/igen/igen.h | 49 ++- sim/igen/ld-cache.c | 16 +- sim/igen/ld-cache.h | 3 +- sim/igen/ld-decode.c | 131 +++--- sim/igen/ld-decode.h | 47 ++- sim/igen/ld-insn.c | 875 +++++++++++++++++++-------------------- sim/igen/ld-insn.h | 172 ++++---- sim/igen/lf.c | 307 +++++++------- sim/igen/lf.h | 100 ++--- sim/igen/misc.c | 70 ++-- sim/igen/misc.h | 41 +- sim/igen/table.c | 131 +++--- sim/igen/table.h | 55 +-- 34 files changed, 2750 insertions(+), 3113 deletions(-) diff --git a/sim/igen/ChangeLog b/sim/igen/ChangeLog index 11cc70f23a0..97ad4ef6fa2 100644 --- a/sim/igen/ChangeLog +++ b/sim/igen/ChangeLog @@ -1,3 +1,15 @@ +2002-11-21 Andrew Cagney + + * 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 * Makefile.in: Update copyright. IGEN contributed to the FSF. diff --git a/sim/igen/filter.c b/sim/igen/filter.c index a5bfef39fdb..ef74fc01b0e 100644 --- a/sim/igen/filter.c +++ b/sim/igen/filter.c @@ -38,15 +38,15 @@ #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) { @@ -54,7 +54,7 @@ filter_parse (filter **filters, 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) { @@ -68,13 +68,12 @@ filter_parse (filter **filters, } /* 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); @@ -87,14 +86,13 @@ filter_parse (filter **filters, 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) @@ -112,7 +110,7 @@ filter_add (filter **set, /* already in set */ add = add->next; } - else /* cmp < 0 */ + else /* cmp < 0 */ { /* not reached insertion point */ set = &(*set)->next; @@ -122,8 +120,7 @@ filter_add (filter **set, int -filter_is_subset (filter *superset, - filter *subset) +filter_is_subset (filter *superset, filter *subset) { while (1) { @@ -131,21 +128,20 @@ filter_is_subset (filter *superset, 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) { @@ -158,7 +154,7 @@ filter_is_common (filter *l, 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; } @@ -166,8 +162,7 @@ filter_is_common (filter *l, int -filter_is_member (filter *filt, - const char *flag) +filter_is_member (filter *filt, const char *flag) { int index = 1; while (filt != NULL) @@ -182,68 +177,72 @@ filter_is_member (filter *filt, 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) { @@ -256,10 +255,7 @@ filter_next (filter *set, 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); @@ -281,20 +277,21 @@ dump_filter (lf *file, #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 ...\n"); - exit (1); - } + if (argc < 2) + { + printf ("Usage: 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 */ @@ -352,7 +349,7 @@ main(int argc, char **argv) dump_filter (l, "{", superset, " }"); lf_printf (l, "\n"); } - + return 0; } #endif diff --git a/sim/igen/filter.h b/sim/igen/filter.h index 79513118143..6cef90956d4 100644 --- a/sim/igen/filter.h +++ b/sim/igen/filter.h @@ -28,62 +28,44 @@ typedef struct _filter filter; /* 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); diff --git a/sim/igen/filter_host.h b/sim/igen/filter_host.h index 79839fe885d..7c6739d079a 100644 --- a/sim/igen/filter_host.h +++ b/sim/igen/filter_host.h @@ -25,6 +25,5 @@ #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 diff --git a/sim/igen/gen-engine.c b/sim/igen/gen-engine.c index 70ede3d0a21..d0f5c30ce71 100644 --- a/sim/igen/gen-engine.c +++ b/sim/igen/gen-engine.c @@ -65,25 +65,25 @@ print_engine_issue_postfix_hook (lf *file) 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: - + X - + 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"); @@ -93,10 +93,10 @@ print_run_body (lf *file, 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\ @@ -124,16 +124,16 @@ cache. */\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); @@ -146,7 +146,8 @@ cache. */\n\ 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); @@ -162,7 +163,8 @@ cache. */\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, cpu, cia);\n"); + lf_putstr (file, + " mon_event (mon_event_icache_miss, cpu, cia);\n"); if (options.gen.semantic_icache) { lf_putstr (file, "{\n"); @@ -183,7 +185,7 @@ cache. */\n\ lf_indent (file, -4); lf_putstr (file, " }\n"); } - + /* update the cpu if necessary */ switch (options.gen.nia) { @@ -210,10 +212,10 @@ cache. */\n\ lf_indent (file, -4); lf_printf (file, " }\n"); } - + if (options.gen.smp) { - + lf_putstr (file, "\ /* CASE 2: SMP (With or without ICACHE)\n\ \n\ @@ -223,9 +225,10 @@ cpu1 will normally be the next cpu that is run. Cpu0 being restarted\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"); @@ -247,7 +250,7 @@ after all the other CPU's and the event queue have been processed */\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"); @@ -258,8 +261,10 @@ after all the other CPU's and the event queue have been processed */\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"); @@ -278,13 +283,14 @@ after all the other CPU's and the event queue have been processed */\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"); @@ -292,8 +298,9 @@ after all the other CPU's and the event queue have been processed */\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 */ @@ -303,7 +310,7 @@ after all the other CPU's and the event queue have been processed */\n\ } lf_putstr (file, "}\n"); } - + lf_putstr (file, "\n"); lf_putstr (file, "current_cpu += 1;\n"); lf_putstr (file, "if (current_cpu == nr_cpus)\n"); @@ -314,13 +321,13 @@ after all the other CPU's and the event queue have been processed */\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"); } @@ -330,8 +337,7 @@ after all the other CPU's and the event queue have been processed */\n\ #if 0 static void -print_jump (lf *file, - int is_tail) +print_jump (lf *file, int is_tail) { if (!options.gen.smp) { @@ -342,7 +348,7 @@ print_jump (lf *file, lf_putstr (file, " }\n"); lf_putstr (file, "}\n"); } - + if (options.gen.smp) { if (is_tail) @@ -359,7 +365,7 @@ print_jump (lf *file, 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"); @@ -367,16 +373,17 @@ print_jump (lf *file, 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 @@ -384,10 +391,9 @@ print_jump (lf *file, #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; @@ -398,9 +404,8 @@ print_jump_insn (lf *file, 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) { @@ -409,24 +414,18 @@ print_jump_insn (lf *file, 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 = &&"); @@ -434,16 +433,13 @@ print_jump_insn (lf *file, 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 { @@ -452,8 +448,7 @@ print_jump_insn (lf *file, 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); @@ -461,16 +456,14 @@ print_jump_insn (lf *file, 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"); @@ -484,12 +477,8 @@ print_jump_insn (lf *file, ? 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, @@ -497,9 +486,8 @@ print_jump_insn (lf *file, 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"); } @@ -508,18 +496,14 @@ print_jump_insn (lf *file, #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 @@ -527,17 +511,11 @@ print_jump_definition (lf *file, && 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 @@ -545,9 +523,7 @@ print_jump_definition (lf *file, #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) { @@ -580,9 +556,7 @@ print_jump_internal_function (lf *file, #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); @@ -599,10 +573,10 @@ print_jump_body (lf *file, { 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) { @@ -613,17 +587,17 @@ print_jump_body (lf *file, 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) { @@ -634,7 +608,7 @@ print_jump_body (lf *file, { lf_putstr (file, "current_cpu = psim_last_cpu(system);\n"); } - + if (!options.gen.icache) { lf_printf (file, "\n"); @@ -642,36 +616,34 @@ print_jump_body (lf *file, 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"); @@ -701,11 +673,8 @@ print_engine_run_function_header (lf *file, 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) { @@ -742,9 +711,7 @@ print_engine_run_function_header (lf *file, 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) @@ -752,17 +719,14 @@ gen_engine_h (lf *file, 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 */ @@ -781,24 +745,22 @@ gen_engine_c(lf *file, { 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; } diff --git a/sim/igen/gen-engine.h b/sim/igen/gen-engine.h index 14c01a0e48b..8f6c0303755 100644 --- a/sim/igen/gen-engine.h +++ b/sim/igen/gen-engine.h @@ -22,19 +22,10 @@ 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); diff --git a/sim/igen/gen-icache.c b/sim/igen/gen-icache.c index 3e77af0938f..693a646e08c 100644 --- a/sim/igen/gen-icache.c +++ b/sim/igen/gen-icache.c @@ -47,13 +47,12 @@ print_icache_function_header (lf *file, 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, ")"); @@ -65,16 +64,15 @@ print_icache_function_header (lf *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); } @@ -99,7 +97,7 @@ print_icache_extraction (lf *file, char *reason; ASSERT (format_name != NULL); ASSERT (entry_name != NULL); - + /* figure out exactly what should be going on here */ switch (cache_type) { @@ -129,30 +127,27 @@ print_icache_extraction (lf *file, { 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) { @@ -180,8 +175,8 @@ print_icache_extraction (lf *file, 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 @@ -193,11 +188,11 @@ print_icache_extraction (lf *file, { /* 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"; @@ -226,52 +221,55 @@ print_icache_extraction (lf *file, "_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, " = "); } @@ -282,10 +280,11 @@ print_icache_extraction (lf *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, @@ -305,7 +304,7 @@ print_icache_extraction (lf *file, } } } - + switch (what_to_declare) { case define_variables: @@ -325,12 +324,11 @@ print_icache_extraction (lf *file, 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); @@ -365,8 +363,8 @@ print_icache_body (lf *file, } 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 @@ -387,13 +385,12 @@ print_icache_body (lf *file, 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"); @@ -404,21 +401,17 @@ print_icache_body (lf *file, /* 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. @@ -426,9 +419,7 @@ print_icache_body (lf *file, 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; @@ -444,12 +435,12 @@ print_icache_body (lf *file, 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; @@ -463,19 +454,15 @@ print_icache_body (lf *file, } } /* 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); } } } @@ -485,29 +472,20 @@ print_icache_body (lf *file, { 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); } } } @@ -518,7 +496,8 @@ print_icache_body (lf *file, typedef struct _form_fields form_fields; -struct _form_fields { +struct _form_fields +{ char *name; filter *fields; form_fields *next; @@ -529,134 +508,131 @@ insn_table_cache_fields (insn_table *isa) { form_fields *forms = NULL; insn_entry *insn; - for (insn = isa->insns; - insn != NULL; - insn = insn->next) { - form_fields **form = &forms; - while (1) - { - if (*form == NULL) - { - /* new format name, add it */ - form_fields *new_form = ZALLOC (form_fields); - new_form->name = insn->format_name; - filter_add (&new_form->fields, insn->field_names); - *form = new_form; - break; - } - else if (strcmp ((*form)->name, insn->format_name) == 0) - { - /* already present, add field names to the existing list */ - filter_add (&(*form)->fields, insn->field_names); - break; - } - form = &(*form)->next; - } - } + 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"); } @@ -665,43 +641,40 @@ print_icache_struct (lf *file, 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); @@ -716,30 +689,25 @@ print_icache_function (lf *file, : 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"); @@ -748,11 +716,10 @@ print_icache_function (lf *file, 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, @@ -762,10 +729,9 @@ print_icache_function (lf *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); @@ -775,25 +741,22 @@ print_icache_function (lf *file, 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); @@ -804,10 +767,7 @@ print_icache_internal_function_declaration (lf *file, "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"); @@ -817,7 +777,7 @@ print_icache_internal_function_declaration (lf *file, void print_icache_internal_function_definition (lf *file, - function_entry *function, + function_entry * function, void *data) { ASSERT (options.gen.icache); @@ -828,10 +788,7 @@ print_icache_internal_function_definition (lf *file, "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"); @@ -842,7 +799,8 @@ print_icache_internal_function_definition (lf *file, { 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 @@ -851,12 +809,10 @@ print_icache_internal_function_definition (lf *file, 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"); diff --git a/sim/igen/gen-icache.h b/sim/igen/gen-icache.h index 7940e37fca8..e2eec439578 100644 --- a/sim/igen/gen-icache.h +++ b/sim/igen/gen-icache.h @@ -25,45 +25,45 @@ /* 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 */ @@ -75,9 +75,7 @@ extern function_entry_handler print_icache_internal_function_definition; /* 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 */ diff --git a/sim/igen/gen-idecode.c b/sim/igen/gen-idecode.c index d15d7015f5b..639b5631ddd 100644 --- a/sim/igen/gen-idecode.c +++ b/sim/igen/gen-idecode.c @@ -40,18 +40,17 @@ 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; } @@ -68,12 +67,12 @@ print_idecode_ifetch (lf *file, { 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); - + } } @@ -83,8 +82,7 @@ print_idecode_ifetch (lf *file, 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); @@ -93,9 +91,7 @@ lf_print_table_name (lf *file, 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 = "); @@ -106,7 +102,7 @@ print_idecode_table (lf *file, 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"); @@ -129,7 +125,7 @@ print_idecode_table (lf *file, 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) @@ -141,14 +137,16 @@ print_idecode_table (lf *file, 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"); @@ -158,10 +156,7 @@ print_idecode_table (lf *file, 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 */ @@ -175,10 +170,7 @@ print_idecode_table_start (lf *file, } 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); @@ -238,9 +230,9 @@ print_idecode_table_leaf (lf *file, 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, "); @@ -251,23 +243,20 @@ print_idecode_table_leaf (lf *file, } 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) @@ -283,21 +272,19 @@ print_goto_switch_name (lf *file, } 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); @@ -307,8 +294,7 @@ print_goto_switch_table_leaf (lf *file, } 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); @@ -317,41 +303,31 @@ print_goto_switch_break (lf *file, 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) @@ -393,16 +369,13 @@ print_idecode_switch_start (lf *file, } 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); @@ -411,19 +384,17 @@ print_idecode_switch_leaf (lf *file, || 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"); @@ -475,7 +446,9 @@ print_idecode_switch_leaf (lf *file, 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"); @@ -512,7 +485,7 @@ print_idecode_switch_leaf (lf *file, } else if (entry->parent->opcode_rule->gen == goto_switch_gen) { - print_goto_switch_break(file, entry); + print_goto_switch_break (file, entry); } else { @@ -525,8 +498,7 @@ print_idecode_switch_leaf (lf *file, 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); @@ -535,10 +507,7 @@ print_idecode_switch_illegal (lf *file, } 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); @@ -546,7 +515,7 @@ print_idecode_switch_end (lf *file, || 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"); @@ -559,7 +528,8 @@ print_idecode_switch_end (lf *file, 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"); } @@ -578,7 +548,7 @@ print_idecode_switch_end (lf *file, 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 @@ -597,16 +567,13 @@ print_idecode_switch_end (lf *file, 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); } @@ -657,47 +624,35 @@ print_idecode_switch_function_header (lf *file, 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); @@ -711,45 +666,32 @@ idecode_expand_if_switch (lf *file, 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 @@ -768,15 +710,14 @@ print_idecode_body (lf *file, #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"); @@ -787,7 +728,7 @@ print_jump (lf *file, lf_putstr (file, " }\n"); lf_putstr (file, "}\n"); } - + if (options.generate_smp) { if (is_tail) @@ -809,7 +750,7 @@ print_jump (lf *file, 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"); @@ -827,7 +768,7 @@ print_jump (lf *file, { lf_printf (file, "goto idecode;\n"); } - + } #endif @@ -836,16 +777,15 @@ print_jump (lf *file, #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) { @@ -853,46 +793,36 @@ print_jump_insn (lf *file, 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); @@ -900,14 +830,13 @@ print_jump_insn (lf *file, 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"); @@ -921,12 +850,8 @@ print_jump_insn (lf *file, ? 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, @@ -934,9 +859,8 @@ print_jump_insn (lf *file, 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"); } @@ -947,17 +871,14 @@ print_jump_insn (lf *file, 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 @@ -965,17 +886,12 @@ print_jump_definition (lf *file, && 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 @@ -984,8 +900,7 @@ print_jump_definition (lf *file, 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) { @@ -1016,9 +931,8 @@ print_jump_internal_function (lf *file, #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); @@ -1027,25 +941,28 @@ print_jump_until_stop_body(lf *file, 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"); @@ -1058,52 +975,51 @@ print_jump_until_stop_body(lf *file, 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"); } @@ -1120,8 +1036,7 @@ print_jump_until_stop_body(lf *file, void print_idecode_validate (lf *file, - insn_entry *instruction, - insn_opcodes *opcode_paths) + insn_entry * instruction, insn_opcodes *opcode_paths) { /* Validate: unchecked instruction fields @@ -1154,27 +1069,24 @@ print_idecode_validate (lf *file, /* 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 @@ -1188,14 +1100,14 @@ print_idecode_validate (lf *file, } 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) { @@ -1205,23 +1117,23 @@ print_idecode_validate (lf *file, 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); @@ -1233,12 +1145,12 @@ print_idecode_validate (lf *file, 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 */ @@ -1249,7 +1161,8 @@ print_idecode_validate (lf *file, 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); @@ -1277,14 +1190,14 @@ print_idecode_validate (lf *file, 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 @@ -1297,7 +1210,8 @@ print_idecode_validate (lf *file, 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); @@ -1307,7 +1221,7 @@ print_idecode_validate (lf *file, lf_printf (file, "#endif\n"); } } - + } @@ -1326,13 +1240,11 @@ print_idecode_issue_function_header (lf *file, { 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); @@ -1343,8 +1255,7 @@ print_idecode_issue_function_header (lf *file, "issue", NULL, processor, - NULL, - function_name_prefix_idecode); + NULL, function_name_prefix_idecode); switch (decl_type) { case is_function_definition: diff --git a/sim/igen/gen-idecode.h b/sim/igen/gen-idecode.h index 9578e6c01b1..18682e4d6d4 100644 --- a/sim/igen/gen-idecode.h +++ b/sim/igen/gen-idecode.h @@ -23,23 +23,16 @@ 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); @@ -49,6 +42,4 @@ void print_idecode_body 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); diff --git a/sim/igen/gen-itable.c b/sim/igen/gen-itable.c index dea71a2ca8a..7b94d37449b 100644 --- a/sim/igen/gen-itable.c +++ b/sim/igen/gen-itable.c @@ -42,18 +42,18 @@ -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; @@ -62,9 +62,7 @@ itable_h_insn (lf *file, 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); @@ -82,16 +80,13 @@ itable_h_insn (lf *file, /* 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); @@ -102,8 +97,9 @@ itable_print_enum (lf *file, 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) @@ -120,9 +116,7 @@ itable_print_enum (lf *file, /* 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", @@ -130,8 +124,7 @@ itable_print_names (lf *file, 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); } @@ -140,16 +133,16 @@ itable_print_names (lf *file, 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"); @@ -158,7 +151,7 @@ gen_itable_h (lf *file, 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", @@ -220,9 +213,7 @@ gen_itable_h (lf *file, /****************************************************************/ 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, "\""); @@ -240,10 +231,9 @@ itable_print_set (lf *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)) { @@ -253,27 +243,23 @@ itable_print_set (lf *file, { 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); @@ -284,22 +270,22 @@ itable_c_insn (lf *file, 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??? */ @@ -312,9 +298,8 @@ gen_itable_c (lf *file, /* 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"); } diff --git a/sim/igen/gen-itable.h b/sim/igen/gen-itable.h index 3134819fd3c..3cc69fba116 100644 --- a/sim/igen/gen-itable.h +++ b/sim/igen/gen-itable.h @@ -25,10 +25,6 @@ /* 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); diff --git a/sim/igen/gen-model.c b/sim/igen/gen-model.c index 98302c03885..8f35f0f1d0c 100644 --- a/sim/igen/gen-model.c +++ b/sim/igen/gen-model.c @@ -40,38 +40,37 @@ #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; @@ -83,161 +82,171 @@ gen_model_h(insn_table *table, lf *file) 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; @@ -248,155 +257,179 @@ gen_model_c(insn_table *table, lf *file) 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 \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 \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 @@ -404,16 +437,14 @@ gen_model_c(insn_table *table, lf *file) 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"); } diff --git a/sim/igen/gen-model.h b/sim/igen/gen-model.h index a0d7773e40e..8dd987228b5 100644 --- a/sim/igen/gen-model.h +++ b/sim/igen/gen-model.h @@ -23,10 +23,6 @@ -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); diff --git a/sim/igen/gen-semantics.c b/sim/igen/gen-semantics.c index ee6b610f857..44a3c5249e5 100644 --- a/sim/igen/gen-semantics.c +++ b/sim/igen/gen-semantics.c @@ -48,7 +48,7 @@ print_semantic_function_header (lf *file, 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" : " ")); @@ -85,52 +85,58 @@ print_semantic_function_header (lf *file, 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); } + - /* 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"); } @@ -139,18 +145,17 @@ print_idecode_invalid (lf *file, 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 */ @@ -177,22 +182,20 @@ print_semantic_body (lf *file, 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 { @@ -218,7 +221,7 @@ print_semantic_body (lf *file, lf_printf (file, "nia = cia + %d * (%d + 1); %s\n", options.insn_bit_size / 8, nr_immeds, "/* skip immeds as well */"); - + } else { @@ -228,7 +231,7 @@ print_semantic_body (lf *file, } } } - + /* if conditional, generate code to verify that the instruction should be issued */ if (filter_is_member (instruction->options, "c") @@ -241,7 +244,7 @@ print_semantic_body (lf *file, 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 */ @@ -251,7 +254,7 @@ print_semantic_body (lf *file, 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"); @@ -287,32 +290,30 @@ print_semantic_body (lf *file, 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, @@ -323,16 +324,13 @@ print_c_semantic (lf *file, : 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) { @@ -343,51 +341,41 @@ print_c_semantic (lf *file, 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); } - - diff --git a/sim/igen/gen-semantics.h b/sim/igen/gen-semantics.h index c8373b5a494..9afc5cf7ffe 100644 --- a/sim/igen/gen-semantics.h +++ b/sim/igen/gen-semantics.h @@ -73,35 +73,29 @@ 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); diff --git a/sim/igen/gen-support.c b/sim/igen/gen-support.c index 407d5f7e25e..d246845b99f 100644 --- a/sim/igen/gen-support.c +++ b/sim/igen/gen-support.c @@ -39,19 +39,16 @@ 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); @@ -71,16 +68,14 @@ print_support_function_name (lf *file, 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", @@ -89,8 +84,7 @@ print_support_function_name (lf *file, 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")); } @@ -98,58 +92,54 @@ print_support_function_name (lf *file, 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 _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 */ @@ -158,55 +148,47 @@ gen_support_h (lf *file, 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); @@ -217,17 +199,17 @@ support_c_function (lf *file, 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); } diff --git a/sim/igen/gen-support.h b/sim/igen/gen-support.h index e05bd9cfedf..4d716c90ef6 100644 --- a/sim/igen/gen-support.h +++ b/sim/igen/gen-support.h @@ -22,11 +22,6 @@ 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); diff --git a/sim/igen/gen.c b/sim/igen/gen.c index d12cb3b1425..0ff15d48793 100644 --- a/sim/igen/gen.c +++ b/sim/igen/gen.c @@ -33,22 +33,16 @@ #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; } @@ -58,21 +52,15 @@ int 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) { @@ -91,8 +79,7 @@ print_gen_entry_path (line_ref *line, 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; @@ -101,10 +88,7 @@ print_gen_entry_insns (gen_entry *table, { 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; } @@ -118,14 +102,12 @@ insn_field_cmp (insn_word_entry *l, insn_word_entry *r) { 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; @@ -138,38 +120,46 @@ insn_field_cmp (insn_word_entry *l, insn_word_entry *r) 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; } @@ -186,14 +176,12 @@ insn_word_cmp (insn_word_entry *l, insn_word_entry *r) { 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; @@ -211,30 +199,29 @@ insn_word_cmp (insn_word_entry *l, insn_word_entry *r) /* 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; @@ -246,14 +233,13 @@ opcode_bit_cmp (opcode_bits *l, /* 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; @@ -267,9 +253,7 @@ static opcode_bits * 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; @@ -277,7 +261,7 @@ new_opcode_bits (opcode_bits *old_bits, new_bits->first = first; new_bits->last = last; new_bits->opcode = opcode; - + if (old_bits != NULL) { opcode_bits *new_list; @@ -286,12 +270,11 @@ new_opcode_bits (opcode_bits *old_bits, 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; } @@ -325,15 +308,17 @@ format_name_cmp (const char *l, const char *r) } -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, @@ -366,12 +351,14 @@ insn_list_insert (insn_list **cur_insn_ptr, 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) @@ -409,7 +396,7 @@ insn_list_insert (insn_list **cur_insn_ptr, } } - + /* create a new list entry and insert it */ { insn_list *new_insn = ZALLOC (insn_list); @@ -424,7 +411,7 @@ insn_list_insert (insn_list **cur_insn_ptr, } (*cur_insn_ptr) = new_insn; } - + *nr_insns += 1; return (*cur_insn_ptr); @@ -435,27 +422,24 @@ 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) + 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) { @@ -482,9 +466,7 @@ gen_entry_traverse_tree (lf *file, /* 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); @@ -498,12 +480,9 @@ make_table (insn_table *isa, || 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); } } @@ -513,8 +492,7 @@ make_table (insn_table *isa, 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; @@ -528,9 +506,7 @@ make_gen_tables (insn_table *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)) { @@ -545,21 +521,22 @@ make_gen_tables (insn_table *isa, } 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) { @@ -573,7 +550,7 @@ insn_field_is_constant (insn_field *field, 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)) @@ -593,13 +570,11 @@ insn_field_is_constant (insn_field *field, /* 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 */ @@ -625,9 +600,9 @@ insns_bit_useless (insn_list *insns, 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) @@ -684,14 +659,13 @@ insns_bit_useless (insn_list *insns, 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) { @@ -702,14 +676,14 @@ insns_bit_useless (insn_list *insns, 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; } @@ -734,8 +708,7 @@ insns_bit_useless (insn_list *insns, 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); @@ -751,14 +724,14 @@ gen_entry_find_opcode_field (insn_list *insns, 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; } @@ -769,62 +742,66 @@ gen_entry_find_opcode_field (insn_list *insns, { 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 @@ -839,21 +816,18 @@ gen_entry_find_opcode_field (insn_list *insns, /* 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; } @@ -883,20 +857,19 @@ gen_entry_find_opcode_field (insn_list *insns, 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 */ @@ -915,22 +888,17 @@ gen_entry_insert_insn (gen_entry *table, } /* 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) { @@ -943,21 +911,20 @@ gen_entry_expand_opcode (gen_entry *table, 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 @@ -965,23 +932,19 @@ gen_entry_expand_opcode (gen_entry *table, 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: @@ -989,18 +952,15 @@ gen_entry_expand_opcode (gen_entry *table, 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; @@ -1011,8 +971,9 @@ gen_entry_expand_opcode (gen_entry *table, { 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: @@ -1032,51 +993,62 @@ gen_entry_expand_opcode (gen_entry *table, 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); } } } @@ -1102,25 +1074,26 @@ printf ("value=%d, opcode_nr=%d, last=%d, [%d..%d]\n", 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); } } } @@ -1131,28 +1104,24 @@ printf ("value=%d, opcode_nr=%d, last=%d, [%d..%d]\n", } 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; } } @@ -1160,8 +1129,7 @@ insns_match_format_names (insn_list *insns, } 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; @@ -1187,8 +1155,7 @@ table_matches_path (gen_entry *table, static int -insns_match_conditions (insn_list *insns, - decode_cond *conditions) +insns_match_conditions (insn_list *insns, decode_cond *conditions) { if (conditions != NULL) { @@ -1208,8 +1175,7 @@ insns_match_conditions (insn_list *insns, 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; } } @@ -1219,8 +1185,7 @@ insns_match_conditions (insn_list *insns, } 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) @@ -1232,8 +1197,7 @@ insns_match_nr_words (insn_list *insns, } static int -insn_list_cmp (insn_list *l, - insn_list *r) +insn_list_cmp (insn_list *l, insn_list *r) { while (1) { @@ -1245,7 +1209,7 @@ insn_list_cmp (insn_list *l, 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) @@ -1262,12 +1226,11 @@ gen_entry_expand_insns (gen_entry *table) { 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 @@ -1281,17 +1244,19 @@ gen_entry_expand_insns (gen_entry *table) 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"; } @@ -1303,18 +1268,18 @@ gen_entry_expand_insns (gen_entry *table) { 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; @@ -1328,7 +1293,7 @@ gen_entry_expand_insns (gen_entry *table) notify (NULL, ": rule discarded - %s\n", discard_reason); } } - + /* did we find anything */ if (opcode_rule == NULL) { @@ -1348,7 +1313,8 @@ gen_entry_expand_insns (gen_entry *table) 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; @@ -1356,7 +1322,7 @@ gen_entry_expand_insns (gen_entry *table) /* 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; } @@ -1371,8 +1337,7 @@ gen_entry_expand_insns (gen_entry *table) 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 */ @@ -1384,8 +1349,7 @@ gen_entry_expand_insns (gen_entry *table) { 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); } @@ -1400,14 +1364,13 @@ gen_entry_expand_insns (gen_entry *table) 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) { @@ -1441,9 +1404,9 @@ gen_entry_expand_insns (gen_entry *table) 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); @@ -1452,42 +1415,42 @@ gen_entry_expand_insns (gen_entry *table) 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 */ @@ -1507,10 +1470,7 @@ gen_entry_expand_insns (gen_entry *table) 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); @@ -1522,7 +1482,7 @@ gen_entry_expand_insns (gen_entry *table) 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; } @@ -1537,7 +1497,7 @@ gen_entry_expand_insns (gen_entry *table) 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) { @@ -1563,12 +1523,9 @@ gen_tables_expand_insns (gen_table *gen) 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 */ @@ -1598,14 +1555,12 @@ gen_tables_expand_semantics (gen_table *gen) 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 */ + } } @@ -1616,34 +1571,30 @@ gen_tables_expand_semantics (gen_table *gen) 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); @@ -1659,28 +1610,25 @@ dump_opcode_bits (lf *file, 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) @@ -1694,39 +1642,37 @@ dump_insn_word_entry_list_entries (lf *file, 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) { @@ -1740,10 +1686,7 @@ dump_gen_list (lf *file, 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); @@ -1756,8 +1699,7 @@ dump_gen_table (lf *file, igen_options options; int -main (int argc, - char **argv) +main (int argc, char **argv) { decode_table *decode_rules; insn_table *instructions; @@ -1765,16 +1707,17 @@ main (int argc, lf *l; if (argc != 7) - error (NULL, "Usage: insn \n"); + error (NULL, + "Usage: insn \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]); diff --git a/sim/igen/gen.h b/sim/igen/gen.h index c919fcce6a4..073a831d87b 100644 --- a/sim/igen/gen.h +++ b/sim/igen/gen.h @@ -23,7 +23,8 @@ typedef struct _opcode_field opcode_field; -struct _opcode_field { +struct _opcode_field +{ int word_nr; int first; int last; @@ -34,7 +35,8 @@ struct _opcode_field { }; typedef struct _opcode_bits opcode_bits; -struct _opcode_bits { +struct _opcode_bits +{ int value; int first; int last; @@ -44,13 +46,15 @@ struct _opcode_bits { }; 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 */ @@ -70,14 +74,15 @@ struct _insn_list { 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; @@ -99,7 +104,8 @@ struct _gen_entry { }; -struct _gen_list { +struct _gen_list +{ model_entry *model; insn_table *isa; gen_entry *table; @@ -108,7 +114,8 @@ struct _gen_list { 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 */ @@ -121,38 +128,28 @@ struct _gen_table { }; -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); @@ -161,70 +158,57 @@ extern void gen_entry_traverse_tree /* 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); - diff --git a/sim/igen/igen.c b/sim/igen/igen.c index d51684babd9..d5896f2e221 100644 --- a/sim/igen/igen.c +++ b/sim/igen/igen.c @@ -55,8 +55,7 @@ /* 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; @@ -74,8 +73,7 @@ print_semantic_function_formal (lf *file, 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); @@ -86,8 +84,7 @@ print_semantic_function_formal (lf *file, 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); @@ -96,8 +93,7 @@ print_semantic_function_formal (lf *file, } 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; @@ -131,15 +127,14 @@ print_semantic_function_type (lf *file) /* 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); @@ -151,8 +146,7 @@ print_icache_function_formal (lf *file, } 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; @@ -186,8 +180,7 @@ print_icache_function_type (lf *file) /* 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) @@ -196,19 +189,21 @@ print_opcode_bits (lf *file, 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; @@ -264,7 +259,7 @@ print_function_name (lf *file, default: break; } - + if (model_name != NULL) { nr += print_c_name (file, model_name); @@ -273,7 +268,7 @@ print_function_name (lf *file, /* the function name */ nr += print_c_name (file, basename); - + /* the format name if available */ if (format_name != NULL) { @@ -291,8 +286,7 @@ print_function_name (lf *file, 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); @@ -301,16 +295,14 @@ print_my_defines (lf *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"); @@ -318,8 +310,7 @@ print_my_defines (lf *file, 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); @@ -329,8 +320,7 @@ print_my_defines (lf *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"); } @@ -340,18 +330,20 @@ print_itrace_prefix (lf *file) { 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; @@ -359,7 +351,7 @@ print_itrace_format (lf *file, 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') { @@ -399,7 +391,8 @@ print_itrace_format (lf *file, } 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) @@ -430,7 +423,8 @@ print_itrace_format (lf *file, 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); @@ -449,7 +443,7 @@ print_itrace_format (lf *file, } } else if (strncmp (fmt, "%#lx<", 5) == 0) - /* simple hex with 0x prefix*/ + /* simple hex with 0x prefix */ { if (pass == 1) lf_printf (file, "%%#lx"); @@ -486,9 +480,7 @@ print_itrace_format (lf *file, 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 @@ -513,8 +505,7 @@ print_itrace (lf *file, { 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); @@ -523,7 +514,8 @@ print_itrace (lf *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 { @@ -541,7 +533,8 @@ print_itrace (lf *file, 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; @@ -562,7 +555,9 @@ print_itrace (lf *file, } 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"); @@ -572,8 +567,7 @@ print_itrace (lf *file, 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); @@ -582,15 +576,13 @@ print_sim_engine_abort (lf *file, 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); @@ -616,9 +608,7 @@ print_includes (lf *file) 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; @@ -626,8 +616,7 @@ gen_semantics_h (lf *file, { 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("); @@ -660,9 +649,7 @@ gen_semantics_h (lf *file, 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) { @@ -697,23 +684,20 @@ gen_semantics_c (lf *file, 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, @@ -737,13 +721,11 @@ gen_icache_h (lf *file, 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"); @@ -779,9 +761,7 @@ gen_icache_c (lf *file, 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); @@ -791,13 +771,14 @@ gen_idecode_h (lf *file, 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) @@ -824,14 +805,14 @@ gen_idecode_h (lf *file, ? 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 */ ); } } } @@ -839,9 +820,7 @@ gen_idecode_h (lf *file, 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); @@ -850,7 +829,7 @@ gen_idecode_c (lf *file, print_idecode_globals (file); lf_printf (file, "\n"); - + switch (options.gen.code) { case generate_calls: @@ -859,7 +838,7 @@ gen_idecode_c (lf *file, 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) { @@ -867,8 +846,8 @@ gen_idecode_c (lf *file, (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", @@ -894,8 +873,7 @@ gen_idecode_c (lf *file, 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"); @@ -906,12 +884,13 @@ gen_run_c (lf *file, 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"); @@ -933,36 +912,27 @@ gen_run_c (lf *file, { 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"); @@ -973,18 +943,17 @@ gen_run_c (lf *file, 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); @@ -994,8 +963,7 @@ gen_run_c (lf *file, /****************************************************************/ 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) @@ -1015,9 +983,7 @@ do_gen (insn_table *isa, 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; @@ -1027,7 +993,8 @@ main (int argc, 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 (); @@ -1041,95 +1008,140 @@ main (int argc, printf ("\n"); printf (" -B \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 \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 \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 .\n"); printf ("\n"); printf (" -H \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 \n"); - printf ("\t Add to the list of directories searched when opening a file\n"); + printf + ("\t Add to the list of directories searched when opening a file\n"); printf ("\n"); printf (" -M \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 \n"); printf ("\t Generate a simulator supporting \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 \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 \n"); - printf ("\t Prepend global names (except itable) with the string .\n"); - printf ("\t Specify -P = to set a specific 's prefix.\n"); + printf + ("\t Prepend global names (except itable) with the string .\n"); + printf + ("\t Specify -P = to set a specific 's prefix.\n"); printf ("\n"); printf (" -S \n"); - printf ("\t Replace a global name (suffix) (except itable) with the string .\n"); - printf ("\t Specify -S = to change a specific 's name (suffix).\n"); + printf + ("\t Replace a global name (suffix) (except itable) with the string .\n"); + printf + ("\t Specify -S = to change a specific '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 [!]\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 - arch assumes GPR() == 0, keep it that way\n"); - printf ("\t gen-icache[= - generate an instruction cracking cache of size \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 - arch assumes GPR() == 0, keep it that way\n"); + printf + ("\t gen-icache[= - generate an instruction cracking cache of size \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"); @@ -1140,8 +1152,10 @@ main (int argc, printf ("Output options:\n"); printf ("\n"); printf (" -x Perform expansion (required)\n"); - printf (" -n 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 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 icache\n"); printf (" -d output idecode\n"); printf (" -e output engine\n"); @@ -1151,19 +1165,19 @@ main (int argc, printf (" -s output schematic\n"); printf (" -t 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; @@ -1184,7 +1198,7 @@ main (int argc, case 'F': filter_parse (&options.flags_filter, optarg); break; - + case 'I': { table_include **dir = &options.include; @@ -1194,7 +1208,7 @@ main (int argc, (*dir)->dir = strdup (optarg); } break; - + case 'B': options.insn_bit_size = a2i (optarg); if (options.insn_bit_size <= 0 @@ -1209,7 +1223,7 @@ main (int argc, 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 @@ -1218,11 +1232,11 @@ main (int argc, 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': { @@ -1237,7 +1251,7 @@ main (int argc, } else { - chp = chp + 1; /* skip `=' */ + chp = chp + 1; /* skip `=' */ names = NULL; if (strncmp (optarg, "global=", chp - optarg) == 0) { @@ -1281,23 +1295,25 @@ main (int argc, 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) @@ -1306,12 +1322,13 @@ main (int argc, 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) @@ -1365,7 +1382,7 @@ main (int argc, { options.decode.zero_reserved = enable_p; } - + else if (strcmp (argp, "gen-conditional-issue") == 0) { options.gen.conditional_issue = enable_p; @@ -1373,7 +1390,8 @@ main (int argc, 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) { @@ -1382,7 +1400,8 @@ main (int argc, 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) { @@ -1391,7 +1410,8 @@ main (int argc, 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) { @@ -1402,28 +1422,32 @@ main (int argc, { options.gen.zero_reg = enable_p; options.gen.zero_reg_nr = atoi (argp + strlen ("zero-r")); - options.warning (NULL, "Option zero-r replaced by gen-zero-r\n"); + options.warning (NULL, + "Option zero-r replaced by gen-zero-r\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"); + error (NULL, + "Expecting -Ggen-icache or -Ggen-icache=\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]) @@ -1431,15 +1455,18 @@ main (int argc, 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=\n"); + error (NULL, + "Expecting -Ggen-multi-sim or -Ggen-multi-sim=\n"); break; } } @@ -1458,7 +1485,8 @@ main (int argc, 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) { @@ -1467,7 +1495,8 @@ main (int argc, 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) { @@ -1519,7 +1548,7 @@ main (int argc, } break; } - + case 'i': isa = load_insn_table (optarg, cache_rules); if (isa->illegal_insn == NULL) @@ -1541,13 +1570,13 @@ main (int argc, 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': @@ -1557,15 +1586,16 @@ main (int argc, 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': @@ -1593,7 +1623,7 @@ main (int argc, 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); @@ -1614,21 +1644,18 @@ main (int argc, 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"); } diff --git a/sim/igen/igen.h b/sim/igen/igen.h index 6367f3bacc9..1ca456e4a94 100644 --- a/sim/igen/igen.h +++ b/sim/igen/igen.h @@ -24,7 +24,8 @@ /* code-generation options: */ -typedef enum { +typedef enum +{ /* Transfer control to an instructions semantic code using the the standard call/return mechanism */ @@ -37,18 +38,22 @@ typedef enum { 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; @@ -87,7 +92,8 @@ struct _igen_gen_options { 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; @@ -96,16 +102,21 @@ struct _igen_trace_options { 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; @@ -113,10 +124,12 @@ typedef struct _igen_module_options { 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 @@ -143,7 +156,8 @@ struct _igen_decode_options { typedef struct _igen_warn_options igen_warn_options; -struct _igen_warn_options { +struct _igen_warn_options +{ /* Issue warning about discarded instructions */ int discard; @@ -159,7 +173,8 @@ struct _igen_warn_options { typedef struct _igen_options igen_options; -struct _igen_options { +struct _igen_options +{ /* What does the instruction look like - bit ordering, size, widths or offesets */ @@ -201,7 +216,7 @@ struct _igen_options { extern igen_options options; -/* default options - hopefully backward compatible */ \ +/* default options - hopefully backward compatible */ #define INIT_OPTIONS() \ do { \ memset (&options, 0, sizeof options); \ diff --git a/sim/igen/ld-cache.c b/sim/igen/ld-cache.c index 3fa75b709c5..c46aa9a1463 100644 --- a/sim/igen/ld-cache.c +++ b/sim/igen/ld-cache.c @@ -37,7 +37,8 @@ #endif -enum { +enum +{ ca_type, ca_field_name, ca_derived_name, @@ -47,10 +48,10 @@ enum { }; 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}, }; @@ -67,8 +68,7 @@ load_cache_table (char *file_name) 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) @@ -101,7 +101,7 @@ load_cache_table (char *file_name) igen_options options; int -main(int argc, char **argv) +main (int argc, char **argv) { cache_entry *rules = NULL; lf *l; diff --git a/sim/igen/ld-cache.h b/sim/igen/ld-cache.h index 168bf3b361c..2ad60ea123e 100644 --- a/sim/igen/ld-cache.h +++ b/sim/igen/ld-cache.h @@ -65,5 +65,4 @@ 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); diff --git a/sim/igen/ld-decode.c b/sim/igen/ld-decode.c index 62b794277fc..856b1ad92ad 100644 --- a/sim/igen/ld-decode.c +++ b/sim/igen/ld-decode.c @@ -39,45 +39,44 @@ 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++) @@ -90,7 +89,7 @@ set_bits (int bit[max_insn_bit_size], } decode_table * -load_decode_table(char *file_name) +load_decode_table (char *file_name) { table *file = table_open (file_name); table_entry *entry; @@ -107,20 +106,22 @@ load_decode_table(char *file_name) /* 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 @@ -169,7 +170,9 @@ load_decode_table(char *file_name) && 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"); @@ -180,7 +183,8 @@ load_decode_table(char *file_name) && 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"); @@ -217,7 +221,7 @@ load_decode_table(char *file_name) { (*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); @@ -244,22 +248,32 @@ load_decode_table(char *file_name) 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; @@ -274,7 +288,7 @@ load_decode_table(char *file_name) return table; } - + int decode_table_max_word_nr (decode_table *entry) { @@ -297,10 +311,7 @@ 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) @@ -318,10 +329,7 @@ dump_decode_cond (lf *file, 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) @@ -334,23 +342,21 @@ dump_decode_conds (lf *file, 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); @@ -369,10 +375,7 @@ dump_decode_rule (lf *file, #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) @@ -388,7 +391,7 @@ dump_decode_rules (lf *file, igen_options options; int -main(int argc, char **argv) +main (int argc, char **argv) { lf *l; decode_table *rules; diff --git a/sim/igen/ld-decode.h b/sim/igen/ld-decode.h index 1060f9c668a..329e80de5d5 100644 --- a/sim/igen/ld-decode.h +++ b/sim/igen/ld-decode.h @@ -133,22 +133,27 @@ */ -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, @@ -156,20 +161,23 @@ enum { }; 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]; @@ -177,13 +185,16 @@ struct _decode_cond { 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, @@ -200,7 +211,8 @@ enum { typedef struct _decode_table decode_table; -struct _decode_table { +struct _decode_table +{ line_ref *line; decode_special_type type; decode_gen_type gen; @@ -226,14 +238,9 @@ struct _decode_table { }; -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); diff --git a/sim/igen/ld-insn.c b/sim/igen/ld-insn.c index 01f1f5ab59f..d74ff5b5a3a 100644 --- a/sim/igen/ld-insn.c +++ b/sim/igen/ld-insn.c @@ -30,9 +30,7 @@ #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); @@ -56,241 +54,244 @@ parse_insn_word (line_ref *line, /* 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 - { [ "!" | "=" [ | } */ - 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)) - { - /* [ "!" | "=" ] */ - 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 - { [ "!" | "=" [ | } */ + 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)) + { + /* [ "!" | "=" ] */ + new_cond->type = insn_field_cond_value; + new_cond->value = a2i (new_cond->string); + } + else + { + /* [ "!" | "=" ] - 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 */ { - /* [ "!" | "=" ] - 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; @@ -308,8 +309,7 @@ parse_insn_word (line_ref *line, { 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++) @@ -324,21 +324,21 @@ parse_insn_word (line_ref *line, 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; } @@ -351,8 +351,7 @@ parse_insn_word (line_ref *line, 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; @@ -408,8 +407,7 @@ parse_insn_words (insn_entry *insn, 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; } @@ -422,14 +420,10 @@ parse_insn_words (insn_entry *insn, { 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) { @@ -447,7 +441,8 @@ parse_insn_words (insn_entry *insn, 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; @@ -456,7 +451,8 @@ parse_insn_words (insn_entry *insn, 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); } } } @@ -469,12 +465,13 @@ parse_insn_words (insn_entry *insn, } } } - + } -typedef enum { +typedef enum +{ unknown_record = 0, - insn_record, /* default */ + insn_record, /* default */ code_record, cache_record, compute_record, @@ -491,25 +488,26 @@ typedef enum { 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}, }; @@ -554,15 +552,13 @@ record_type (table_entry *entry) 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; @@ -577,8 +573,7 @@ static table_entry * 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; @@ -612,7 +607,8 @@ parse_model_data_record (insn_table *isa, } -typedef enum { +typedef enum +{ insn_bit_size_option = 1, insn_specifying_widths_option, hi_bit_nr_option, @@ -622,23 +618,23 @@ typedef enum { 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) @@ -651,7 +647,7 @@ parse_include_record (table *file, { 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; @@ -659,8 +655,7 @@ parse_include_record (table *file, 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 */ @@ -684,10 +679,12 @@ parse_option_record (table *file, 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: @@ -700,7 +697,8 @@ parse_option_record (table *file, 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: @@ -734,7 +732,7 @@ parse_option_record (table *file, break; } } - } + } return record; } @@ -742,10 +740,9 @@ parse_option_record (table *file, 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); @@ -779,7 +776,7 @@ parse_function_record (table *file, 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)) { @@ -804,7 +801,8 @@ parse_function_record (table *file, && !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 @@ -822,8 +820,7 @@ parse_function_record (table *file, 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); @@ -835,11 +832,11 @@ parse_insn_model_record (table *file, /* 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) @@ -858,7 +855,8 @@ parse_insn_model_record (table *file, 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) { @@ -866,8 +864,7 @@ parse_insn_model_record (table *file, "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); @@ -896,8 +893,7 @@ parse_insn_model_record (table *file, 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); @@ -906,10 +902,13 @@ parse_insn_mnemonic_record (table *file, 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; @@ -921,8 +920,7 @@ parse_insn_mnemonic_record (table *file, 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"); @@ -941,7 +939,7 @@ parse_macro_record (table *file, record->field[macro_name_field], record->field[macro_args_field], record->field[macro_expr_field]); - } + } record = table_read (file); #endif return record; @@ -949,15 +947,14 @@ parse_macro_record (table *file, 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; @@ -980,22 +977,20 @@ load_insn_table (char *file_name, 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; @@ -1003,13 +998,12 @@ load_insn_table (char *file_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; } @@ -1020,11 +1014,10 @@ load_insn_table (char *file_name, 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; @@ -1051,8 +1044,8 @@ load_insn_table (char *file_name, } break; } - - case scratch_record: /* cache macro records */ + + case scratch_record: /* cache macro records */ case cache_record: case compute_record: { @@ -1076,13 +1069,16 @@ load_insn_table (char *file_name, /* 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 @@ -1097,14 +1093,15 @@ load_insn_table (char *file_name, 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); @@ -1117,13 +1114,16 @@ load_insn_table (char *file_name, /* 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)) @@ -1139,70 +1139,69 @@ load_insn_table (char *file_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]); @@ -1210,12 +1209,14 @@ load_insn_table (char *file_name, 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; @@ -1244,8 +1245,8 @@ load_insn_table (char *file_name, 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", @@ -1262,7 +1263,7 @@ load_insn_table (char *file_name, 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); @@ -1270,7 +1271,7 @@ load_insn_table (char *file_name, } break; } - + case define_record: record = parse_macro_record (file, record); break; @@ -1287,8 +1288,7 @@ load_insn_table (char *file_name, 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) @@ -1301,7 +1301,8 @@ print_insn_words (lf *file, 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: @@ -1332,14 +1333,13 @@ print_insn_words (lf *file, } } } + - 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) @@ -1351,8 +1351,7 @@ function_entry_traverse (lf *file, 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) @@ -1360,13 +1359,11 @@ insn_table_traverse_insn (lf *file, handler (file, isa, insn, data); } } - + 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) @@ -1385,9 +1382,7 @@ dump_function_entry (lf *file, 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); @@ -1405,26 +1400,27 @@ cache_entry_type_to_str (cache_entry_type type) { 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); @@ -1435,10 +1431,7 @@ dump_cache_entry (lf *file, } 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); @@ -1452,10 +1445,7 @@ dump_cache_entries (lf *file, } 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) @@ -1472,10 +1462,7 @@ dump_model_data (lf *file, } 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); @@ -1489,10 +1476,7 @@ dump_model_datas (lf *file, } 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) @@ -1510,10 +1494,7 @@ dump_model_entry (lf *file, } 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); @@ -1528,10 +1509,7 @@ dump_model_entries (lf *file, 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) @@ -1556,11 +1534,17 @@ insn_field_type_to_str (insn_field_type type) { 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; @@ -1568,9 +1552,7 @@ insn_field_type_to_str (insn_field_type type) 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); @@ -1580,7 +1562,8 @@ dump_insn_field (lf *file, 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: @@ -1608,9 +1591,7 @@ dump_insn_field (lf *file, 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) @@ -1623,7 +1604,8 @@ dump_insn_word_entry (lf *file, 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, ")"); @@ -1636,9 +1618,7 @@ dump_insn_word_entry (lf *file, 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) @@ -1651,9 +1631,7 @@ dump_insn_word_entries (lf *file, 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) @@ -1673,9 +1651,7 @@ dump_insn_model_entry (lf *file, 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) @@ -1690,10 +1666,10 @@ dump_insn_model_entries (lf *file, 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); @@ -1712,8 +1688,7 @@ dump_insn_mnemonic_entry (lf *file, 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) @@ -1725,10 +1700,7 @@ dump_insn_mnemonic_entries (lf *file, } 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) @@ -1754,19 +1726,17 @@ dump_insn_entry (lf *file, 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); @@ -1782,10 +1752,7 @@ dump_insn_entries (lf *file, 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) diff --git a/sim/igen/ld-insn.h b/sim/igen/ld-insn.h index a8dd456612c..08a6bd09413 100644 --- a/sim/igen/ld-insn.h +++ b/sim/igen/ld-insn.h @@ -38,7 +38,8 @@ typedef unsigned64 insn_uint; */ -enum { +enum +{ record_type_field = 1, old_record_type_field = 2, record_filter_flags_field = 2, @@ -60,7 +61,8 @@ enum { */ -enum { +enum +{ include_filename_field = 4, nr_include_fields, }; @@ -99,10 +101,11 @@ enum { ; - These update the global options structure. */ + These update the global options structure. */ -enum { +enum +{ option_name_field = 4, option_value_field, nr_option_fields, @@ -129,7 +132,8 @@ enum { */ -enum { +enum +{ macro_name_field = 4, macro_args_field, macro_expr_field, @@ -177,29 +181,33 @@ enum { */ -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; @@ -213,15 +221,11 @@ struct _function_entry { 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: @@ -258,7 +262,8 @@ extern void function_entry_traverse */ -enum { +enum +{ cache_typedef_field = 4, cache_name_field, cache_original_fields_field, @@ -266,14 +271,17 @@ enum { 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; @@ -332,7 +340,8 @@ struct _cache_entry { */ -enum { +enum +{ nr_model_macro_fields = 4, nr_model_data_fields = 4, nr_model_static_fields = nr_function_fields, @@ -341,7 +350,8 @@ enum { }; typedef struct _model_data model_data; -struct _model_data { +struct _model_data +{ line_ref *line; filter *flags; table_entry *entry; @@ -349,7 +359,8 @@ struct _model_data { model_data *next; }; -enum { +enum +{ model_name_field = 4, model_full_name_field, model_unit_data_field, @@ -357,7 +368,8 @@ enum { }; typedef struct _model_entry model_entry; -struct _model_entry { +struct _model_entry +{ line_ref *line; filter *flags; char *name; @@ -368,7 +380,8 @@ struct _model_entry { typedef struct _model_table model_table; -struct _model_table { +struct _model_table +{ filter *processors; int nr_models; model_entry *models; @@ -410,16 +423,21 @@ struct _model_table { */ -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; @@ -429,16 +447,19 @@ struct _insn_field_cond { }; -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; @@ -453,7 +474,8 @@ struct _insn_field_entry { }; typedef struct _insn_bit_entry insn_bit_entry; -struct _insn_bit_entry { +struct _insn_bit_entry +{ int value; int mask; insn_field_entry *field; @@ -462,10 +484,11 @@ struct _insn_bit_entry { -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; @@ -499,14 +522,16 @@ struct _insn_word_entry { */ -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; @@ -554,14 +579,16 @@ struct _insn_model_entry { */ -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; @@ -586,7 +613,8 @@ struct _insn_mnemonic_entry { */ -enum { +enum +{ insn_word_field = 0, insn_format_name_field = 1, insn_filter_flags_field = 2, @@ -597,9 +625,10 @@ enum { /* 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; @@ -630,7 +659,8 @@ struct _insn_entry { */ typedef struct _insn_table insn_table; -struct _insn_table { +struct _insn_table +{ cache_entry *caches; int max_nr_words; int nr_insns; @@ -642,65 +672,37 @@ struct _insn_table { 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); diff --git a/sim/igen/lf.c b/sim/igen/lf.c index 5364f41113c..42985f2a887 100644 --- a/sim/igen/lf.c +++ b/sim/igen/lf.c @@ -43,9 +43,10 @@ #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; @@ -59,70 +60,73 @@ lf * 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; @@ -133,63 +137,63 @@ lf_write (lf *file, 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]; @@ -200,28 +204,25 @@ lf_printf (lf *file, /* 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, " \""); @@ -243,7 +244,7 @@ int 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; } @@ -259,10 +260,11 @@ int 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\ @@ -285,110 +287,115 @@ lf_print__gnu_copyleft (lf *file) --\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; } @@ -396,8 +403,7 @@ lf_print__file_finish(lf *file) 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); @@ -408,7 +414,7 @@ lf_print__function_type (lf *file, int lf_print__function_type_function (lf *file, - print_function *print_type, + print_function * print_type, const char *prefix, const char *trailing_space) { @@ -420,4 +426,3 @@ lf_print__function_type_function (lf *file, nr += lf_printf (file, "%s", trailing_space); return nr; } - diff --git a/sim/igen/lf.h b/sim/igen/lf.h index ff79558a587..7eb4ee4024a 100644 --- a/sim/igen/lf.h +++ b/sim/igen/lf.h @@ -27,17 +27,21 @@ 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 @@ -47,44 +51,28 @@ typedef enum { 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. @@ -92,56 +80,38 @@ extern int lf_printf 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); diff --git a/sim/igen/misc.c b/sim/igen/misc.c index 6283482b0d6..c5389268fe8 100644 --- a/sim/igen/misc.c +++ b/sim/igen/misc.c @@ -46,9 +46,7 @@ trailing '\n' */ void -error (const line_ref *line, - char *msg, - ...) +error (const line_ref *line, char *msg, ...) { va_list ap; if (line != NULL) @@ -60,9 +58,7 @@ error (const line_ref *line, } void -warning (const line_ref *line, - char *msg, - ...) +warning (const line_ref *line, char *msg, ...) { va_list ap; if (line != NULL) @@ -73,25 +69,23 @@ warning (const line_ref *line, } 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; } @@ -103,16 +97,14 @@ a2i (const char *a) 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 == '-') @@ -120,7 +112,7 @@ a2i (const char *a) neg = 1; a++; } - + if (*a == '0') { if (a[1] == 'x' || a[1] == 'X') @@ -136,18 +128,18 @@ a2i (const char *a) else base = 8; } - + looping = 1; while (looping) { int ch = *a++; - + switch (base) { default: looping = 0; break; - + case 2: if (ch >= '0' && ch <= '1') { @@ -158,7 +150,7 @@ a2i (const char *a) looping = 0; } break; - + case 10: if (ch >= '0' && ch <= '9') { @@ -169,7 +161,7 @@ a2i (const char *a) looping = 0; } break; - + case 8: if (ch >= '0' && ch <= '7') { @@ -180,7 +172,7 @@ a2i (const char *a) looping = 0; } break; - + case 16: if (ch >= '0' && ch <= '9') { @@ -201,26 +193,24 @@ a2i (const char *a) 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; @@ -230,20 +220,19 @@ i2target(int ms_bit_nr, 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 @@ -274,8 +263,7 @@ name2i (const char *names, } const char * -i2name (const int i, - const name_map *map) +i2name (const int i, const name_map * map) { while (map->name != NULL) { diff --git a/sim/igen/misc.h b/sim/igen/misc.h index 7efb37c34e1..54e6c9fb2a4 100644 --- a/sim/igen/misc.h +++ b/sim/igen/misc.h @@ -28,7 +28,8 @@ #include "config.h" -enum { +enum +{ default_insn_bit_size = 32, max_insn_bit_size = 64, }; @@ -42,7 +43,7 @@ enum { typedef long long signed64; typedef unsigned long long unsigned64; -#else /* _WIN32 */ +#else /* _WIN32 */ typedef __int64 signed64; typedef unsigned __int64 unsigned64; @@ -77,16 +78,14 @@ 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; @@ -118,19 +117,13 @@ do { \ #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 @@ -139,15 +132,13 @@ extern unsigned long long a2i 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); diff --git a/sim/igen/table.c b/sim/igen/table.c index 05e4ecc2b38..29f7188ea03 100644 --- a/sim/igen/table.c +++ b/sim/igen/table.c @@ -43,7 +43,8 @@ #endif typedef struct _open_table open_table; -struct _open_table { +struct _open_table +{ size_t size; char *buffer; char *pos; @@ -52,13 +53,14 @@ struct _open_table { 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; @@ -66,8 +68,7 @@ current_line (open_table *file) } 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); @@ -78,19 +79,16 @@ new_table_entry (open_table *file, } 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; @@ -115,7 +113,8 @@ table_push (table *root, 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); @@ -143,7 +142,7 @@ table_push (table *root, exit (1); } include = include->next; - } + } /* determine the size */ @@ -152,7 +151,7 @@ table_push (table *root, 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); @@ -161,15 +160,16 @@ table_push (table *root, 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); @@ -197,9 +197,7 @@ skip_spaces (char *chp) { while (1) { - if (*chp == '\0' - || *chp == '\n' - || !isspace (*chp)) + if (*chp == '\0' || *chp == '\n' || !isspace (*chp)) return chp; chp++; } @@ -211,8 +209,7 @@ back_spaces (char *start, char *chp) { while (1) { - if (chp <= start - || !isspace (chp[-1])) + if (chp <= start || !isspace (chp[-1])) return chp; chp--; } @@ -223,17 +220,14 @@ skip_digits (char *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) { @@ -258,14 +252,14 @@ skip_to_null (char *chp) 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') @@ -282,7 +276,7 @@ table_read (table *root) { open_table *file = root->current; table_entry *entry = NULL; - while(1) + while (1) { /* end-of-file? */ @@ -301,7 +295,7 @@ table_read (table *root) 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 "}" */ @@ -368,7 +362,7 @@ table_read (table *root) 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; } } @@ -389,27 +383,28 @@ table_read (table *root) 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); @@ -498,40 +493,35 @@ table_read (table *root) } 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++; } @@ -541,17 +531,14 @@ table_print_code (lf *file, 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) @@ -570,17 +557,17 @@ table_entry_type_to_str (table_entry_type type) { 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) @@ -604,7 +591,7 @@ dump_table_entry(lf *file, #ifdef MAIN int -main(int argc, char **argv) +main (int argc, char **argv) { table *t; table_entry *entry; @@ -613,7 +600,7 @@ main(int argc, char **argv) if (argc != 2) { - printf("Usage: table \n"); + printf ("Usage: table \n"); exit (1); } @@ -625,7 +612,7 @@ main(int argc, char **argv) { char line[10]; entry = table_read (t); - line_nr ++; + line_nr++; sprintf (line, "(%d ", line_nr); dump_table_entry (l, line, entry, ")\n"); } diff --git a/sim/igen/table.h b/sim/igen/table.h index 190127471c8..1a9e42c435a 100644 --- a/sim/igen/table.h +++ b/sim/igen/table.h @@ -64,14 +64,17 @@ 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; @@ -82,7 +85,8 @@ struct _table_entry { /* 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; }; @@ -91,68 +95,47 @@ struct _table_include { /* 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); -- 2.30.2