From 8782bfcfc466158aeb9433586b6d885641b507df Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Thu, 9 Oct 1997 08:35:33 +0000 Subject: [PATCH] Add -Wnodiscard option so that warning about discarded instructions can be suppressed. Allow `` { | }'' in instruction file. --- sim/igen/ChangeLog | 33 + sim/igen/igen.c | 15 +- sim/igen/igen.h | 217 +++-- sim/igen/ld-insn.c | 2218 ++++++++++++++++++++++++++++++++-------------------- 4 files changed, 1555 insertions(+), 928 deletions(-) diff --git a/sim/igen/ChangeLog b/sim/igen/ChangeLog index 4c7ffa2..91f8e5a 100644 --- a/sim/igen/ChangeLog +++ b/sim/igen/ChangeLog @@ -1,7 +1,40 @@ +Wed Oct 8 13:10:16 1997 Andrew Cagney + + * gen.c (insn_list_insert): Missing \n in warning. + + * ld-insn.c (load_insn_table): Only notify of discarded + instrctions when warn.discard enabled. + + * igen.h: Add option.warn.discard, default enabled. + + * igen.c (main): Add -Wnodiscard option. + + * ld-insn.c (record_type): For old record type, check the number + of fields is correct. + (load_insn_table): Allow insn assembler and insn model records to + appear in any order. + (parse_insn_model_record): Rename from parse_insn_model_records. + Parse only one record. + (parse_insn_mnemonic_record): Rename from + parse_insn_mnemonic_records. Parse only one record. + +Tue Sep 23 15:52:06 1997 Felix Lee + + * gen-itable.c (gen_itable_h): [nr_itable_* + 1] to avoid + illegal zero-sized array. + (itable_print_set): likewise, avoid empty initializers. + +Mon Sep 22 18:49:07 1997 Felix Lee + + * configure.in: i386-windows is a cross, so don't expect + libiberty to be there. + * configure: updated. + Fri Sep 19 10:36:30 1997 Andrew Cagney * igen.c (print_function_name): Put the format name after the function / instruction name, not before. + (print_itrace): Better format trace code. Tue Sep 16 11:01:07 1997 Andrew Cagney diff --git a/sim/igen/igen.c b/sim/igen/igen.c index 28e6e15..7820603 100644 --- a/sim/igen/igen.c +++ b/sim/igen/igen.c @@ -491,8 +491,9 @@ print_itrace (lf *file, lf_indent_suppress (file); lf_printf (file, "#if defined (WITH_TRACE)\n"); lf_printf (file, "/* trace the instructions execution if enabled */\n"); - lf_printf (file, "if (TRACE_%s_P (CPU)) {\n", phase); - lf_indent (file, +2); + lf_printf (file, "if (TRACE_%s_P (CPU))\n", phase); + lf_printf (file, " {\n"); + lf_indent (file, +4); if (insn->mnemonics != NULL) { insn_mnemonic_entry *assembler = insn->mnemonics; @@ -541,8 +542,8 @@ print_itrace (lf *file, lf_printf (file, "itable[MY_INDEX].name);\n"); lf_indent (file, -indent); } - lf_indent (file, -2); - lf_printf (file, "}\n"); + lf_indent (file, -4); + lf_printf (file, " }\n"); lf_indent_suppress (file); lf_printf (file, "#endif\n"); } @@ -989,6 +990,8 @@ main (int argc, printf ("\n"); printf (" -Werror\n"); printf ("\t Make warnings errors\n"); + printf (" -Wnodiscard\n"); + printf ("\t Suppress warnings about discarded instructions\n"); printf ("\n"); printf (" -G [!]\n"); printf ("\t Any of the following options:\n"); @@ -1186,6 +1189,10 @@ main (int argc, { if (strcmp (optarg, "error") == 0) options.warning = error; + else if (strcmp (optarg, "nodiscard") == 0) + options.warn.discard = 0; + else if (strcmp (optarg, "discard") == 0) + options.warn.discard = 1; else error (NULL, "Unknown -W argument `%s'\n", optarg); break; diff --git a/sim/igen/igen.h b/sim/igen/igen.h index 3d894bf..188e3e4 100644 --- a/sim/igen/igen.h +++ b/sim/igen/igen.h @@ -18,127 +18,180 @@ */ - -/* What does the instruction look like - bit ordering, size, widths or offesets */ -extern int hi_bit_nr; -extern int insn_bit_size; -extern int insn_specifying_widths; - - -/* what should global names be prefixed with? */ -extern const char *global_name_prefix; -extern const char *global_uname_prefix; - - -/* generation options: */ - - -enum { - generate_with_direct_access = 0x1, - generate_with_icache = 0x2, - generate_with_semantic_icache = 0x4, - generate_with_insn_in_icache = 0x8, - - generate_with_semantic_returning_modified_nia_only = 0x010, - generate_with_semantic_conditional_issue = 0x020, - generate_with_idecode_slot_verification = 0x040, - generate_with_semantic_delayed_branch = 0x080, - generate_with_semantic_zero_r0 = 0x100 -}; - +/* code-generation options: */ typedef enum { /* Transfer control to an instructions semantic code using the the standard call/return mechanism */ - generate_calls = 0x1000, - + generate_calls, /* Transfer control to an instructions semantic code using (computed) goto's instead of the more conventional call/return mechanism */ - generate_jumps = 0x2000, - + generate_jumps, } igen_code; -extern int code; - - - +typedef enum { + nia_is_cia_plus_one, + nia_is_void, + nia_is_invalid, +} igen_nia; -extern int icache_size; -/* Instruction expansion? +typedef struct _igen_gen_options igen_gen_options; +struct _igen_gen_options { + int direct_access; + int semantic_icache; + int insn_in_icache; + int conditional_issue; + int slot_verification; + int delayed_branch; - Should the semantic code for each instruction, when the oportunity - arrises, be expanded according to the variable opcode files that - the instruction decode process renders constant */ + /* If zeroing a register, which one? */ + int zero_reg; + int zero_reg_nr; -extern int generate_expanded_instructions; + /* should multiple simulators be generated? */ + int multi_sim; + /* should the simulator support multi word instructions and if so, + what is the max nr of words. */ + int multi_word; -/* SMP? + /* SMP? Should the generated code include SMP support (>0) and if + so, for how many processors? */ + int smp; - Should the generated code include SMP support (>0) and if so, for - how many processors? */ + /* how should the next instruction address be computed? */ + igen_nia nia; -extern int generate_smp; + /* nr of instructions in the decoded instruction cache */ + int icache; + int icache_size; + /* see above */ + igen_code code; +}; +typedef struct _igen_trace_options igen_trace_options; +struct _igen_trace_options { + int rule_selection; + int rule_rejection; + int entries; + int combine; +}; -/* Misc junk */ +typedef struct _igen_prefix_name { + char *name; + char *uname; +} igen_prefix_name; + +typedef struct _igen_prefix_options { + igen_prefix_name global; + igen_prefix_name engine; + igen_prefix_name icache; + igen_prefix_name idecode; + igen_prefix_name itable; + igen_prefix_name semantics; + igen_prefix_name support; +} igen_prefix_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 + same instructions. Those entries being merged into a single + table */ + int combine; + + /* Instruction expansion? Should the semantic code for each + instruction, when the oportunity arrises, be expanded according + to the variable opcode files that the instruction decode process + renders constant */ + int duplicate; + + /* Treat reserved fields as constant (zero) instead of ignoring + their value when determining decode tables */ + int zero_reserved; + + /* Convert any padded switch rules into goto_switch */ + int switch_as_goto; + + /* Force all tables to be generated with this lookup mechanism */ + char *overriding_gen; +}; +typedef struct _igen_warn_options igen_warn_options; +struct _igen_warn_options { + int discard; +}; -/* Function header definitions */ +typedef struct _igen_options igen_options; +struct _igen_options { -/* Cache functions: */ + /* What does the instruction look like - bit ordering, size, widths or + offesets */ + int hi_bit_nr; + int insn_bit_size; + int insn_specifying_widths; -extern int print_icache_function_formal -(lf *file); + /* what should global names be prefixed with? */ + igen_prefix_options prefix; -extern int print_icache_function_actual -(lf *file); + /* See above for options and flags */ + igen_gen_options gen; -extern int print_icache_function_type -(lf *file); + /* See above for trace options */ + igen_trace_options trace; -extern int print_semantic_function_formal -(lf *file); + /* See above for decode options */ + igen_decode_options decode; -extern int print_semantic_function_actual -(lf *file); + /* Filter set to be used on the flag field of the instruction table */ + filter *flags_filter; -extern int print_semantic_function_type -(lf *file); + /* See above for warn options */ + igen_warn_options warn; -extern void print_my_defines -(lf *file, - insn_bits *expanded_bits, - table_entry *file_entry); + /* Be more picky about the input */ + error_func (*warning); -extern void print_itrace -(lf *file, - table_entry *file_entry, - int idecode); + /* Model (processor) set - like flags_filter. Used to select the + specific ISA within a processor family. */ + filter *model_filter; + /* Format name set */ + filter *format_name_filter; +}; -typedef enum { - function_name_prefix_semantics, - function_name_prefix_idecode, - function_name_prefix_itable, - function_name_prefix_icache, - function_name_prefix_none -} lf_function_name_prefixes; - -extern int print_function_name -(lf *file, - const char *basename, - insn_bits *expanded_bits, - lf_function_name_prefixes prefix); +extern igen_options options; + +/* default options - hopefully backward compatible */ \ +#define INIT_OPTIONS(OPTIONS) \ +do { \ + memset (&(OPTIONS), 0, sizeof (OPTIONS)); \ + memset (&(OPTIONS).warn, -1, sizeof ((OPTIONS).warn)); \ + (OPTIONS).hi_bit_nr = 0; \ + (OPTIONS).insn_bit_size = default_insn_bit_size; \ + (OPTIONS).insn_specifying_widths = 0; \ + (OPTIONS).prefix.global.name = ""; \ + (OPTIONS).prefix.global.uname = ""; \ + (OPTIONS).prefix.engine = (OPTIONS).prefix.global; \ + (OPTIONS).prefix.icache = (OPTIONS).prefix.global; \ + (OPTIONS).prefix.idecode = (OPTIONS).prefix.global; \ + (OPTIONS).prefix.itable = (OPTIONS).prefix.global; \ + (OPTIONS).prefix.semantics = (OPTIONS).prefix.global; \ + (OPTIONS).prefix.support = (OPTIONS).prefix.global; \ + (OPTIONS).gen.code = generate_calls; \ + (OPTIONS).gen.icache_size = 1024; \ + (OPTIONS).warning = warning; \ +} while (0) diff --git a/sim/igen/ld-insn.c b/sim/igen/ld-insn.c index 4baa73d..8d33a3e 100644 --- a/sim/igen/ld-insn.c +++ b/sim/igen/ld-insn.c @@ -23,997 +23,1531 @@ #include "lf.h" #include "table.h" #include "filter.h" -#include "ld-decode.h" -#include "ld-cache.h" -#include "ld-insn.h" - #include "igen.h" +#include "ld-insn.h" -static void -update_depth(insn_table *entry, - lf *file, - void *data, - insn *instruction, - int depth) -{ - int *max_depth = (int*)data; - if (*max_depth < depth) - *max_depth = depth; -} - - -int -insn_table_depth(insn_table *table) -{ - int depth = 0; - insn_table_traverse_tree(table, - NULL, - &depth, - 1, - NULL, /*start*/ - update_depth, - NULL, /*end*/ - NULL); /*padding*/ - return depth; -} - - -static insn_fields * -parse_insn_format(table_entry *entry, - char *format) +static insn_word_entry * +parse_insn_word (line_ref *line, + char *string, + int word_nr) { char *chp; - insn_fields *fields = ZALLOC(insn_fields); + insn_word_entry *word = ZALLOC (insn_word_entry); /* create a leading sentinal */ - fields->first = ZALLOC(insn_field); - fields->first->first = -1; - fields->first->last = -1; - fields->first->width = 0; + word->first = ZALLOC (insn_field_entry); + word->first->first = -1; + word->first->last = -1; + word->first->width = 0; /* and a trailing sentinal */ - fields->last = ZALLOC(insn_field); - fields->last->first = insn_bit_size; - fields->last->last = insn_bit_size; - fields->last->width = 0; + word->last = ZALLOC (insn_field_entry); + word->last->first = options.insn_bit_size; + word->last->last = options.insn_bit_size; + word->last->width = 0; /* link them together */ - fields->first->next = fields->last; - fields->last->prev = fields->first; + word->first->next = word->last; + word->last->prev = word->first; /* now work through the formats */ - chp = format; + chp = skip_spaces (string); while (*chp != '\0') { char *start_pos; + int strlen_pos; char *start_val; int strlen_val; - int strlen_pos; - insn_field *new_field; + insn_field_entry *new_field; - /* skip leading spaces */ - while (isspace(*chp) && *chp != '\n') - chp++; + /* 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; - while (*chp != '\0' - && !isspace(*chp) - && *chp != '.' - && *chp != ',') { - chp++; - } - strlen_pos = chp - start_pos; + chp = skip_to_separator (chp, ".,!"); + strlen_pos = back_spaces (start_pos, chp) - start_pos; /* break out the second field (if present) */ - if (*chp != '.') { - /* assume that the value length specifies the nr of bits */ - start_val = start_pos; - strlen_val = strlen_pos; - start_pos = ""; - strlen_pos = 0; - } - else { - chp++; - start_val = chp; - if (*chp == '/' || *chp == '*') { - do { - chp++; - } while (*chp == '/' || *chp == '*'); + 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 if (isalpha(*start_val)) { - do { - chp++; - } while (isalnum(*chp) || *chp == '_'); + 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 (isalnum(*chp)); + } + strlen_val = chp - start_val; + chp = skip_spaces (chp); } - else if (isdigit(*start_val)) { - do { - chp++; - } while (isalnum(*chp)); + if (strlen_val == 0) + error (line, "Empty value field"); + + /* break out any conditional fields - { "!" } */ + while (*chp == '!') + { + char *start; + int len; + insn_field_exclusion *new_exclusion = ZALLOC (insn_field_exclusion); + insn_field_exclusion **last; + + /* what type of conditional field */ + chp++; + chp = skip_spaces (chp); + /* the value */ + start = chp; + chp = skip_digits (chp); + len = chp - start; + if (len == 0) + error (line, "Missing or invalid conditional value\n"); + /* fill in the entry */ + new_exclusion->string = NZALLOC (char, len + 1); + strncpy (new_exclusion->string, start, len); + new_exclusion->value = a2i (new_exclusion->string); + /* insert it */ + last = &new_field->exclusions; + while (*last != NULL) + last = &(*last)->next; + *last = new_exclusion; + chp = skip_spaces (chp); } - strlen_val = chp - start_val; - } - - /* skip trailing spaces */ - while (isspace(*chp)) - chp++; - /* verify field finished */ + /* NOW verify that the field ws finished */ if (*chp == ',') - chp++; - else if (*chp != '\0' || strlen_val == 0) { - error("%s:%d: missing field terminator at %s\n", - entry->file_name, entry->line_nr, chp); - break; - } - - /* create a new field and insert it */ - new_field = ZALLOC(insn_field); - new_field->next = fields->last; - new_field->prev = fields->last->prev; - new_field->next->prev = new_field; - new_field->prev->next = new_field; + { + chp = skip_spaces (chp + 1); + if (*chp == '\0') + error (line, "empty field\n"); + } + else if (*chp != '\0') + { + error (line, "Missing field separator"); + } - /* the value */ - new_field->val_string = (char*)zalloc(strlen_val+1); - strncpy(new_field->val_string, start_val, strlen_val); - if (isdigit(new_field->val_string[0])) { - if (strlen_pos == 0) { - insn_int val = 0; - int i; - for (i = 0; i < strlen_val; i++) { - if (start_val[i] != '0' && start_val[i] != '1') - error("%s:%d: invalid binary field %s\n", - entry->file_name, entry->line_nr, start_val); - val = (val << 1) + (start_val[i] == '1'); - } - new_field->val_int = val; - new_field->is_int = 1; + /* 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 { - new_field->val_int = a2i(new_field->val_string); - new_field->is_int = 1; + 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->exclusions != NULL) + error (line, "Exclusions only apply to name 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*/ } - } - else if (new_field->val_string[0] == '/') { - new_field->is_reserved = 1; - } - else if (new_field->val_string[0] == '*') { - new_field->is_wild = 1; - } - else { - new_field->is_string = 1; - } - - /* the pos */ - new_field->pos_string = (char*)zalloc(strlen_pos+1); - strncpy(new_field->pos_string, start_pos, strlen_pos); - if (strlen_pos == 0) { - new_field->first = new_field->prev->last + 1; - new_field->width = strlen_val; - new_field->last = new_field->first + new_field->width - 1; - if (new_field->last >= insn_bit_size) - error("%s:%d: Bit position %d exceed instruction bit size (%d)", - entry->file_name, entry->line_nr, - new_field->last, insn_bit_size); - } - else if (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 >= insn_bit_size) - error("%s:%d: Bit position %d exceed instruction bit size (%d)", - entry->file_name, entry->line_nr, - new_field->last, insn_bit_size); - } - else { - new_field->first = target_a2i(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(fields->first->last < 0); - ASSERT(fields->last->first >= insn_bit_size); - fields->first = fields->first->next; - fields->last = fields->last->prev; + /* fiddle first/last so that the sentinals disapear */ + ASSERT(word->first->last < 0); + ASSERT(word->last->first >= options.insn_bit_size); + word->first = word->first->next; + word->last = word->last->prev; + + /* check that the last field goes all the way to the last bit */ + if (word->last->last != options.insn_bit_size - 1) + { + options.warning (line, "Instruction format is not %d bits wide\n", + options.insn_bit_size); + word->last->last = options.insn_bit_size - 1; + } /* now go over this again, pointing each bit position at a field record */ { - int i; - insn_field *field; - field = fields->first; - for (i = 0; i < insn_bit_size; i++) { - while (field->last < i) - field = field->next; - fields->bits[i] = field; - } + insn_field_entry *field; + for (field = word->first; + field->last < options.insn_bit_size; + field = field->next) + { + int i; + for (i = field->first; i <= field->last; i++) + { + word->bit[i] = ZALLOC (insn_bit_entry); + word->bit[i]->field = field; + switch (field->type) + { + case insn_field_int: + word->bit[i]->mask = 1; + word->bit[i]->value = ((field->val_int + & ((insn_uint)1 << (field->last - i))) + != 0); + case insn_field_reserved: + case insn_field_wild: + case insn_field_string: + break; + } + } + } } - /* go over each of the fields, and compute a `value' for the insn */ - { - insn_field *field; - fields->value = 0; - for (field = fields->first; - field->last < insn_bit_size; - field = field->next) { - fields->value <<= field->width; - if (field->is_int) - fields->value |= field->val_int; - } - } - return fields; + return word; } static void -model_table_insert(insn_table *table, - table_entry *file_entry) +parse_insn_words (insn_entry *insn, + char *formats) { - int len; + insn_word_entry **last_word = &insn->words; + char *chp; - /* create a new model */ - model *new_model = ZALLOC(model); + /* now work through the formats */ + insn->nr_words = 0; + chp = formats; + + while (1) + { + char *start_pos; + char *end_pos; + int strlen_pos; + char *format; + insn_word_entry *new_word; + + /* skip leading spaces */ + chp = skip_spaces (chp); + + /* break out the format */ + start_pos = chp; + chp = skip_to_separator (chp, "+"); + end_pos = back_spaces (start_pos, chp); + strlen_pos = end_pos - start_pos; + + /* check that something was there */ + if (strlen_pos == 0) + error (insn->line, "missing or empty instruction format\n"); + + /* parse the field */ + format = NZALLOC (char, strlen_pos + 1); + strncpy (format, start_pos, strlen_pos); + new_word = parse_insn_word (insn->line, format, insn->nr_words); + insn->nr_words++; + if (filter_is_common (insn->field_names, new_word->field_names)) + error (insn->line, "Field name duplicated between two words\n"); + filter_add (&insn->field_names, new_word->field_names); + + /* insert it */ + *last_word = new_word; + last_word = &new_word->next; + + /* last format? */ + if (*chp == '\0') + break; + ASSERT (*chp == '+'); + chp++; + } - new_model->name = file_entry->fields[model_identifer]; - new_model->printable_name = file_entry->fields[model_name]; - new_model->insn_default = file_entry->fields[model_default]; + /* now create a quick access array of the same structure */ + { + int i; + 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) + insn->word[i] = word; + } +} - while (*new_model->insn_default && isspace(*new_model->insn_default)) - new_model->insn_default++; +typedef enum { + unknown_record = 0, + insn_record, /* default */ + code_record, + cache_record, + compute_record, + scratch_record, + option_record, + string_function_record, + function_record, + internal_record, + define_record, + model_processor_record, + model_macro_record, + model_data_record, + model_static_record, + model_function_record, + model_internal_record, +} 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 }, + { "%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 }, +}; - len = strlen(new_model->insn_default); - if (max_model_fields_len < len) - max_model_fields_len = len; - /* append it to the end of the model list */ - if (last_model) - last_model->next = new_model; - else - models = new_model; - last_model = new_model; +static int +record_is_old (table_entry *entry) +{ + if (entry->nr_fields > record_type_field + && strlen (entry->field[record_type_field]) == 0) + return 1; + return 0; } -static void -model_table_insert_specific(insn_table *table, - table_entry *file_entry, - insn **start_ptr, - insn **end_ptr) -{ - insn *ptr = ZALLOC(insn); - ptr->file_entry = file_entry; - if (*end_ptr) - (*end_ptr)->next = ptr; - else - (*start_ptr) = ptr; - (*end_ptr) = ptr; +static insn_record_type +record_type (table_entry *entry) +{ + switch (entry->type) + { + case table_code_entry: + return code_record; + + case table_colon_entry: + if (record_is_old (entry)) + { + /* old-format? */ + if (entry->nr_fields > old_record_type_field) + { + int i = name2i (entry->field[old_record_type_field], + insn_type_map); + return i; + } + else + { + return unknown_record; + } + } + else if (entry->nr_fields > record_type_field + && entry->field[0][0] == '\0') + { + /* new-format? */ + int i = name2i (entry->field[record_type_field], + insn_type_map); + return i; + } + else + return insn_record; /* default */ + } + return unknown_record; } - -static void -insn_table_insert_function(insn_table *table, - table_entry *file_entry) +static int +record_prefix_is (table_entry *entry, + char ch, + int nr_fields) { - /* create a new function */ - insn *new_function = ZALLOC(insn); - new_function->file_entry = file_entry; + if (entry->type != table_colon_entry) + return 0; + if (entry->nr_fields < nr_fields) + return 0; + if (entry->field[0][0] != ch && ch != '\0') + return 0; + return 1; +} - /* append it to the end of the function list */ - if (table->last_function) - table->last_function->next = new_function; - else - table->functions = new_function; - table->last_function = new_function; -} - -extern void -insn_table_insert_insn(insn_table *table, - table_entry *file_entry, - insn_fields *fields) -{ - insn **ptr_to_cur_insn = &table->insns; - insn *cur_insn = *ptr_to_cur_insn; - table_model_entry *insn_model_ptr; - model *model_ptr; - - /* create a new instruction */ - insn *new_insn = ZALLOC(insn); - new_insn->file_entry = file_entry; - new_insn->fields = fields; - - /* Check out any model information returned to make sure the model - is correct. */ - for(insn_model_ptr = file_entry->model_first; insn_model_ptr; insn_model_ptr = insn_model_ptr->next) { - char *name = insn_model_ptr->fields[insn_model_name]; - int len = strlen (insn_model_ptr->fields[insn_model_fields]); - - while (len > 0 && isspace(*insn_model_ptr->fields[insn_model_fields])) { - len--; - insn_model_ptr->fields[insn_model_fields]++; +static table_entry * +parse_model_data_record (insn_table *isa, + table *file, + table_entry *record, + int nr_fields, + model_data **list) +{ + table_entry *model_record = record; + table_entry *code_record = NULL; + model_data *new_data; + if (record->nr_fields < nr_fields) + error (record->line, "Incorrect number of fields\n"); + record = table_read (file); + if (record->type == table_code_entry) + { + code_record = record; + record = table_read (file); } + /* create the new data record */ + new_data = ZALLOC (model_data); + new_data->line = model_record->line; + filter_parse (&new_data->flags, + model_record->field[record_filter_flags_field]); + new_data->entry = model_record; + new_data->code = code_record; + /* append it */ + while (*list != NULL) + list = &(*list)->next; + *list = new_data; + return record; +} - if (max_model_fields_len < len) - max_model_fields_len = len; - for(model_ptr = models; model_ptr; model_ptr = model_ptr->next) { - if (strcmp(name, model_ptr->printable_name) == 0) { +typedef enum { + insn_bit_size_option = 1, + insn_specifying_widths_option, + hi_bit_nr_option, + flags_filter_option, + model_filter_option, + multi_sim_option, + format_names_option, + unknown_option, +} 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 }, + { NULL, unknown_option }, +}; + +static table_entry * +parse_option_record (table *file, + table_entry *record) +{ + table_entry *option_record; + /* parse the option record */ + option_record = record; + if (record->nr_fields < nr_option_fields) + error (record->line, "Incorrect nr of fields for option record\n"); + record = table_read (file); + /* process it */ + if (!is_filtered_out (options.flags_filter, + option_record->field[record_filter_flags_field])) + { + char *name = option_record->field[option_name_field]; + option_names option = name2i (name, option_map); + char *value = option_record->field[option_value_field]; + switch (option) + { + case insn_bit_size_option: + { + 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"); + 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"); + break; + } + case insn_specifying_widths_option: + { + options.insn_specifying_widths = a2i (value); + break; + } + case hi_bit_nr_option: + { + options.hi_bit_nr = a2i (value); + if (options.hi_bit_nr != 0 + && options.hi_bit_nr != options.insn_bit_size - 1) + error (option_record->line, "hi-bit-nr / insn-bit-size conflict\n"); + break; + } + case flags_filter_option: + { + filter_parse (&options.flags_filter, value); + break; + } + case model_filter_option: + { + filter_parse (&options.model_filter, value); + break; + } + case multi_sim_option: + { + options.gen.multi_sim = a2i (value); + break; + } + case format_names_option: + { + filter_parse (&options.format_name_filter, value); + break; + } + case unknown_option: + { + error (option_record->line, "Unknown option - %s\n", name); + break; + } + } + } + return record; +} - /* Replace the name field with that of the global model, so that when we - want to print it out, we can just compare pointers. */ - insn_model_ptr->fields[insn_model_name] = model_ptr->printable_name; - break; - } +static table_entry * +parse_function_record (table *file, + table_entry *record, + function_entry **list, + function_entry **list_entry, + int is_internal) +{ + function_entry *new_function; + if (record->nr_fields < nr_function_fields) + error (record->line, "Missing fields from function record\n"); + /* look for a body to the function */ + new_function = ZALLOC (function_entry); + /* parse the function header */ + new_function->line = record->line; + filter_parse (&new_function->flags, + record->field[record_filter_flags_field]); + if (record_is_old (record)) + new_function->type = record->field[old_function_typedef_field]; + else + new_function->type = record->field[function_typedef_field]; + new_function->name = record->field[function_name_field]; + if (record->nr_fields > function_param_field) + new_function->param = record->field[function_param_field]; + new_function->is_internal = is_internal; + /* parse the function body */ + record = table_read (file); + if (record->type == table_code_entry) + { + new_function->code = record; + record = table_read (file); } + /* insert it */ + while (*list != NULL) + list = &(*list)->next; + *list = new_function; + if (list_entry != NULL) + *list_entry = new_function; + /* done */ + return record; +} - if (!model_ptr) - error("%s:%d: machine model `%s' was not known about\n", - file_entry->file_name, file_entry->line_nr, name); - } - - /* insert it according to the order of the fields */ - while (cur_insn != NULL - && new_insn->fields->value >= cur_insn->fields->value) { - ptr_to_cur_insn = &cur_insn->next; - cur_insn = *ptr_to_cur_insn; - } +static void +parse_insn_model_record (table *file, + table_entry *record, + insn_entry *insn, + model_table *model) +{ + insn_model_entry **last_insn_model; + insn_model_entry *new_insn_model = ZALLOC (insn_model_entry); + /* parse it */ + new_insn_model->line = record->line; + if (record->nr_fields > insn_model_name_field) + new_insn_model->name = record->field[insn_model_name_field]; + if (record->nr_fields > insn_model_unit_data_field) + new_insn_model->unit_data = record->field[insn_model_unit_data_field]; + new_insn_model->insn = insn; + /* strip "\*[ ]*" from name */ + new_insn_model->name = skip_spaces (new_insn_model->name + 1); + if (strlen (new_insn_model->name) == 0) + { + /* No processor name - a generic model entry, enter it into all + the non-empty fields */ + int index; + for (index = 0; index < model->nr_models; index++) + if (insn->model[index] == 0) + { + insn->model[index] = new_insn_model; + } + /* also add the complete processor set to this processor's set */ + filter_add (&insn->processors, model->processors); + } + else + { + /* Find the corresponding master model record so it can be + linked in correctly */ + int index; + index = filter_is_member (model->processors, new_insn_model->name) - 1; + if (index < 0) + { + error (record->line, "machine model `%s' undefined\n", + new_insn_model->name); + } + /* store it in the corresponding model array entry */ + insn->model[index] = new_insn_model; + /* also add the name to the instructions processor set as an + alternative lookup mechanism */ + filter_parse (&insn->processors, new_insn_model->name); + } +#if 0 + /* for some reason record the max length of any + function unit field */ + int len = strlen (insn_model_ptr->field[insn_model_fields]); + if (model->max_model_fields_len < len) + model->max_model_fields_len = len; +#endif + /* link it in */ + last_insn_model = &insn->models; + while ((*last_insn_model) != NULL) + last_insn_model = &(*last_insn_model)->next; + *last_insn_model = new_insn_model; +} - new_insn->next = cur_insn; - *ptr_to_cur_insn = new_insn; - table->nr_insn++; +static void +parse_insn_mnemonic_record (table *file, + table_entry *record, + insn_entry *insn) +{ + insn_mnemonic_entry **last_insn_mnemonic; + insn_mnemonic_entry *new_insn_mnemonic = ZALLOC (insn_mnemonic_entry); + /* parse it */ + new_insn_mnemonic->line = record->line; + if (record->nr_fields > insn_mnemonic_format_field) + new_insn_mnemonic->format = record->field[insn_mnemonic_format_field]; + if (record->nr_fields > 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; + while ((*last_insn_mnemonic) != NULL) + last_insn_mnemonic = &(*last_insn_mnemonic)->next; + insn->nr_mnemonics++; + *last_insn_mnemonic = new_insn_mnemonic; } - insn_table * -load_insn_table(const char *file_name, - decode_table *decode_rules, - filter *filters) -{ - table *file = table_open(file_name, nr_insn_table_fields, nr_insn_model_table_fields); - insn_table *table = ZALLOC(insn_table); - table_entry *file_entry; - table->opcode_rule = decode_rules; - - while ((file_entry = table_entry_read(file)) != NULL) { - if (it_is("function", file_entry->fields[insn_flags]) - || it_is("internal", file_entry->fields[insn_flags])) { - insn_table_insert_function(table, file_entry); - } - else if (it_is("model", file_entry->fields[insn_flags])) { - model_table_insert(table, file_entry); - } - else if (it_is("model-macro", file_entry->fields[insn_flags])) { - model_table_insert_specific(table, file_entry, &model_macros, &last_model_macro); - } - else if (it_is("model-function", file_entry->fields[insn_flags])) { - model_table_insert_specific(table, file_entry, &model_functions, &last_model_function); - } - else if (it_is("model-internal", file_entry->fields[insn_flags])) { - model_table_insert_specific(table, file_entry, &model_internal, &last_model_internal); - } - else if (it_is("model-static", file_entry->fields[insn_flags])) { - model_table_insert_specific(table, file_entry, &model_static, &last_model_static); - } - else if (it_is("model-data", file_entry->fields[insn_flags])) { - model_table_insert_specific(table, file_entry, &model_data, &last_model_data); - } - else { - insn_fields *fields; - /* skip instructions that aren't relevant to the mode */ - if (is_filtered_out(file_entry->fields[insn_flags], filters)) { - fprintf(stderr, "Dropping %s - %s\n", - file_entry->fields[insn_name], - file_entry->fields[insn_flags]); - } - else { - /* create/insert the new instruction */ - fields = parse_insn_format(file_entry, - file_entry->fields[insn_format]); - insn_table_insert_insn(table, file_entry, fields); - } +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; + + while (record != NULL) + { + + switch (record_type (record)) + { + + case option_record: + { + if (isa->insns != NULL) + error (record->line, "Option after first instruction\n"); + record = parse_option_record (file, record); + break; + } + + case string_function_record: + { + /* convert a string function field into an internal function field */ + char *name; + if (record->nr_fields < nr_function_fields) + error (record->line, "Incorrect nr of fields for %s record\n"); + name = NZALLOC (char, + (strlen ("str_") + + strlen (record->field[function_name_field]) + + 1)); + strcat (name, "str_"); + strcat (name, record->field[function_name_field]); + record->field[record_type_field] = "function"; + record->field[function_typedef_field] = "const char *"; + record->field[function_name_field] = name; + /* HACK - comes round back as a function/internal record */ + break; + } + + case function_record: /* function record */ + { + record = parse_function_record (file, record, + &isa->functions, + NULL, + 0/*is-internal*/); + break; + } + + case internal_record: + { + /* only insert it into the function list if it is unknown */ + function_entry *function = NULL; + record = parse_function_record (file, record, + &isa->functions, + &function, + 1/*is-internal*/); + /* check what was inserted to see if a pseudo-instruction + entry also needs to be created */ + if (function != NULL) + { + insn_entry **insn = NULL; + if (strcmp (function->name, "illegal") == 0) + { + /* illegal function save it away */ + if (isa->illegal_insn != NULL) + { + warning (function->line, + "Multiple illegal instruction definitions\n"); + error (isa->illegal_insn->line, + "Location of first illegal instruction\n"); + } + else + insn = &isa->illegal_insn; + } + if (insn != NULL) + { + *insn = ZALLOC (insn_entry); + (*insn)->line = function->line; + (*insn)->name = function->name; + (*insn)->code = function->code; + } + } + break; + } + + case scratch_record: /* cache macro records */ + case cache_record: + case compute_record: + { + cache_entry *new_cache; + /* parse the cache record */ + if (record->nr_fields < nr_cache_fields) + error (record->line, + "Incorrect nr of fields for scratch/cache/compute record\n"); + /* create it */ + new_cache = ZALLOC (cache_entry); + new_cache->line = record->line; + filter_parse (&new_cache->flags, + record->field[record_filter_flags_field]); + new_cache->type = record->field[cache_type_field]; + new_cache->name = record->field[cache_name_field]; + filter_parse (&new_cache->original_fields, + record->field[cache_original_fields_field]); + new_cache->expression = record->field[cache_expression_field]; + /* 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\n", + new_cache->name); + } + else + { + cache_entry **last; + last = &isa->caches; + while (*last != NULL) + last = &(*last)->next; + *last = new_cache; + } + /* advance things */ + record = table_read (file); + break; + } + + /* 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"); + if (isa->insns != NULL) + error (record->line, "Model appears after first instruction\n"); + new_model = ZALLOC (model_entry); + filter_parse (&new_model->flags, + record->field[record_filter_flags_field]); + new_model->line = record->line; + new_model->name = record->field[model_name_field]; + new_model->full_name = record->field[model_full_name_field]; + new_model->unit_data = record->field[model_unit_data_field]; + /* 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\n", + new_model->name); + } + else if (filter_is_member (model->processors, new_model->name)) + { + error (new_model->line, "Duplicate processor model %s\n", + new_model->name); + } + else + { + model_entry **last; + last = &model->models; + while (*last != NULL) + last = &(*last)->next; + *last = new_model; + /* count it */ + 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*/); + break; + + case model_internal_record: + record = parse_function_record (file, record, + &model->internals, + NULL, + 1/*is internal*/); + break; + + case model_function_record: + record = parse_function_record (file, record, + &model->functions, + NULL, + 0/*is internal*/); + break; + + 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"); + 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 */ + 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", + new_insn->format_name); + filter_parse (&new_insn->options, + record->field[insn_options_field]); + new_insn->name = record->field[insn_name_field]; + record = table_read (file); + /* Parse any model/assember records */ + new_insn->nr_models = model->nr_models; + new_insn->model = NZALLOC (insn_model_entry*, model->nr_models + 1); + 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)) + parse_insn_mnemonic_record (file, record, new_insn); + else + break; + /* advance */ + record = table_read (file); + } + /* Parse the code record */ + if (record != NULL && record->type == table_code_entry) + { + new_insn->code = record; + record = table_read (file); + } + /* insert it */ + if (!filter_is_subset (options.flags_filter, new_insn->flags)) + { + if (options.warn.discard) + notify (new_insn->line, + "Discarding instruction %s (flags-filter)\n", + new_insn->name); + } + else if (new_insn->processors != NULL + && options.model_filter != NULL + && !filter_is_common (options.model_filter, + new_insn->processors)) + { + /* only discard an instruction based in the processor + model when both the instruction and the options are + nonempty */ + if (options.warn.discard) + notify (new_insn->line, + "Discarding instruction %s (processor-model)\n", + new_insn->name); + } + else + { + insn_entry **last; + /* finish the parsing */ + parse_insn_words (new_insn, format); + /* append it */ + last = &isa->insns; + while (*last) + last = &(*last)->next; + *last = new_insn; + /* update global isa counters */ + 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); + filter_add (&isa->options, new_insn->options); + } + break; + } + + default: + error (record->line, "Unknown entry\n"); + } } - } - return table; + return isa; } -extern void -insn_table_traverse_tree(insn_table *table, - lf *file, - void *data, - int depth, - leaf_handler *start, - insn_handler *leaf, - leaf_handler *end, - padding_handler *padding) +void +print_insn_words (lf *file, + insn_entry *insn) { - insn_table *entry; - int entry_nr; - - ASSERT(table != NULL - && table->opcode != NULL - && table->nr_entries > 0 - && table->entries != 0); - - if (start != NULL && depth >= 0) - start(table, file, data, depth); - - for (entry_nr = 0, entry = table->entries; - entry_nr < (table->opcode->is_boolean - ? 2 - : (1 << (table->opcode->last - table->opcode->first + 1))); - entry_nr ++) { - if (entry == NULL - || (!table->opcode->is_boolean - && entry_nr < entry->opcode_nr)) { - if (padding != NULL && depth >= 0) - padding(table, file, data, depth, entry_nr); - } - else { - ASSERT(entry != NULL && (entry->opcode_nr == entry_nr - || table->opcode->is_boolean)); - if (entry->opcode != NULL && depth != 0) { - insn_table_traverse_tree(entry, file, data, depth+1, - start, leaf, end, padding); - } - else if (depth >= 0) { - if (leaf != NULL) - leaf(entry, file, data, entry->insns, depth); - } - entry = entry->sibling; + insn_word_entry *word = insn->words; + if (word != NULL) + { + while (1) + { + insn_field_entry *field = word->first; + while (1) + { + if (options.insn_specifying_widths) + lf_printf (file, "%d.", field->width); + else + lf_printf (file, "%d.", i2target (options.hi_bit_nr, field->first)); + switch (field->type) + { + case insn_field_int: + lf_printf (file, "0x%lx", (long) field->val_int); + break; + case insn_field_reserved: + lf_printf (file, "/"); + break; + case insn_field_wild: + lf_printf (file, "*"); + break; + case insn_field_string: + lf_printf (file, "%s", field->val_string); + break; + } + if (field == word->last) + break; + field = field->next; + lf_printf (file, ","); + } + word = word->next; + if (word == NULL) + break; + lf_printf (file, "+"); + } } - } - if (end != NULL && depth >= 0) - end(table, file, data, depth); } -extern void -insn_table_traverse_function(insn_table *table, - lf *file, - void *data, - function_handler *leaf) + +void +function_entry_traverse (lf *file, + function_entry *functions, + function_entry_handler *handler, + void *data) { - insn *function; - for (function = table->functions; - function != NULL; - function = function->next) { - leaf(table, file, data, function->file_entry); - } + function_entry *function; + for (function = functions; function != NULL; function = function->next) + { + handler (file, function, data); + } } -extern void -insn_table_traverse_insn(insn_table *table, - lf *file, - void *data, - insn_handler *handler) +void +insn_table_traverse_insn (lf *file, + insn_table *isa, + insn_entry_handler *handler, + void *data) { - insn *instruction; - for (instruction = table->insns; - instruction != NULL; - instruction = instruction->next) { - handler(table, file, data, instruction, 0); - } + insn_entry *insn; + for (insn = isa->insns; insn != NULL; insn = insn->next) + { + handler (file, isa, insn, data); + } } + +static void +dump_function_entry (lf *file, + char *prefix, + function_entry *entry, + char *suffix) +{ + lf_printf (file, "%s(function_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(type \"%s\")", entry->type); + lf_printf (file, "\n(name \"%s\")", entry->name); + lf_printf (file, "\n(param \"%s\")", entry->param); + dump_table_entry (file, "\n(code ", entry->code, ")"); + lf_printf (file, "\n(is_internal %d)", entry->is_internal); + lf_printf (file, "\n(next 0x%lx)", (long) entry->next); + } + lf_printf (file, "%s", suffix); +} -/****************************************************************/ - -typedef enum { - field_constant_int = 1, - field_constant_reserved = 2, - field_constant_string = 3 -} constant_field_types; - +static void +dump_function_entries (lf *file, + char *prefix, + function_entry *entry, + char *suffix) +{ + lf_printf (file, "%s", prefix); + lf_indent (file, +1); + while (entry != NULL) + { + dump_function_entry (file, "\n(", entry, ")"); + entry = entry->next; + } + lf_indent (file, -1); + lf_printf (file, "%s", suffix); +} -static int -insn_field_is_constant(insn_field *field, - decode_table *rule) -{ - /* field is an integer */ - if (field->is_int) - return field_constant_int; - /* field is `/' and treating that as a constant */ - if (field->is_reserved && rule->force_reserved) - return field_constant_reserved; - /* field, though variable is on the list */ - if (field->is_string && rule->force_expansion != NULL) { - char *forced_fields = rule->force_expansion; - while (*forced_fields != '\0') { - int field_len; - char *end = strchr(forced_fields, ','); - if (end == NULL) - field_len = strlen(forced_fields); - else - field_len = end-forced_fields; - if (strncmp(forced_fields, field->val_string, field_len) == 0 - && field->val_string[field_len] == '\0') - return field_constant_string; - forced_fields += field_len; - if (*forced_fields == ',') - forced_fields++; +static char * +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"; } - } + ERROR ("Bad switch"); return 0; } - -static opcode_field * -insn_table_find_opcode_field(insn *insns, - decode_table *rule, - int string_only) -{ - opcode_field *curr_opcode = ZALLOC(opcode_field); - insn *entry; - ASSERT(rule); - - curr_opcode->first = insn_bit_size; - curr_opcode->last = -1; - for (entry = insns; entry != NULL; entry = entry->next) { - insn_fields *fields = entry->fields; - opcode_field new_opcode; - - /* 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->bits[new_opcode.first], - rule) != field_constant_string) - && (string_only - || !insn_field_is_constant(fields->bits[new_opcode.first], - rule))) - new_opcode.first = fields->bits[new_opcode.first]->last + 1; - ASSERT(new_opcode.first > rule->last - || (string_only - && insn_field_is_constant(fields->bits[new_opcode.first], - rule) == field_constant_string) - || (!string_only - && insn_field_is_constant(fields->bits[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->bits[new_opcode.last], - rule) != field_constant_string) - && (string_only - || !insn_field_is_constant(fields->bits[new_opcode.last], - rule))) - new_opcode.last = fields->bits[new_opcode.last]->first - 1; - ASSERT(new_opcode.last < rule->first - || (string_only - && insn_field_is_constant(fields->bits[new_opcode.last], - rule) == field_constant_string) - || (!string_only - && insn_field_is_constant(fields->bits[new_opcode.last], - rule))); - - /* now see if our current opcode needs expanding */ - 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; - - } - - /* was any thing interesting found? */ - if (curr_opcode->first > rule->last) { - ASSERT(curr_opcode->last < rule->first); - return NULL; - } - ASSERT(curr_opcode->last >= rule->first); - ASSERT(curr_opcode->first <= rule->last); - - /* if something was found, check it includes the forced field range */ - if (!string_only - && curr_opcode->first > rule->force_first) { - curr_opcode->first = rule->force_first; - } - if (!string_only - && curr_opcode->last < rule->force_last) { - curr_opcode->last = rule->force_last; - } - /* handle special case elminating any need to do shift after mask */ - if (string_only - && rule->force_last == insn_bit_size-1) { - curr_opcode->last = insn_bit_size-1; - } - - /* handle any special cases */ - switch (rule->type) { - case normal_decode_rule: - /* let the above apply */ - break; - case expand_forced_rule: - /* expand a limited nr of bits, ignoring the rest */ - curr_opcode->first = rule->force_first; - curr_opcode->last = rule->force_last; - break; - case boolean_rule: - curr_opcode->is_boolean = 1; - curr_opcode->boolean_constant = rule->special_constant; - break; - default: - error("Something is going wrong\n"); - } - - return curr_opcode; +static void +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(name \"%s\")", entry->name); + dump_filter (file, "\n(original_fields ", entry->original_fields, ")"); + lf_printf (file, "\n(type \"%s\")", entry->type); + lf_printf (file, "\n(expression \"%s\")", entry->expression); + lf_printf (file, "\n(next 0x%lx)", (long) entry->next); + } + lf_printf (file, "%s", suffix); } +void +dump_cache_entries (lf *file, + char *prefix, + cache_entry *entry, + char *suffix) +{ + lf_printf (file, "%s", prefix); + lf_indent (file, +1); + while (entry != NULL) + { + dump_cache_entry (file, "\n(", entry, ")"); + entry = entry->next; + } + lf_indent (file, -1); + lf_printf (file, "%s", suffix); +} static void -insn_table_insert_expanded(insn_table *table, - insn *old_insn, - int new_opcode_nr, - insn_bits *new_bits) -{ - insn_table **ptr_to_cur_entry = &table->entries; - insn_table *cur_entry = *ptr_to_cur_entry; - - /* find the new table for this entry */ - while (cur_entry != NULL - && cur_entry->opcode_nr < new_opcode_nr) { - ptr_to_cur_entry = &cur_entry->sibling; - cur_entry = *ptr_to_cur_entry; - } - - if (cur_entry == NULL || cur_entry->opcode_nr != new_opcode_nr) { - insn_table *new_entry = ZALLOC(insn_table); - new_entry->opcode_nr = new_opcode_nr; - new_entry->expanded_bits = new_bits; - new_entry->opcode_rule = table->opcode_rule->next; - new_entry->sibling = cur_entry; - new_entry->parent = table; - *ptr_to_cur_entry = new_entry; - cur_entry = new_entry; - table->nr_entries++; - } - /* ASSERT new_bits == cur_entry bits */ - ASSERT(cur_entry != NULL && cur_entry->opcode_nr == new_opcode_nr); - insn_table_insert_insn(cur_entry, - old_insn->file_entry, - old_insn->fields); +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) + { + lf_indent (file, +1); + dump_line_ref (file, "\n(line ", entry->line, ")"); + dump_filter (file, "\n(flags ", entry->flags, ")"); + dump_table_entry (file, "\n(entry ", entry->entry, ")"); + 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", prefix); } static void -insn_table_expand_opcode(insn_table *table, - insn *instruction, - int field_nr, - int opcode_nr, - insn_bits *bits) +dump_model_datas (lf *file, + char *prefix, + model_data *entry, + char *suffix) { - - if (field_nr > table->opcode->last) { - insn_table_insert_expanded(table, instruction, opcode_nr, bits); - } - else { - insn_field *field = instruction->fields->bits[field_nr]; - if (field->is_int) { - if (!(field->first >= table->opcode->first - && field->last <= table->opcode->last)) - error("%s:%d: Instruction field %s.%s [%d..%d] overlaps sub-field [%d..%d] boundary", - instruction->file_entry->file_name, - instruction->file_entry->line_nr, - field->pos_string, field->val_string, - field->first, field->last, - table->opcode->first, table->opcode->last); - insn_table_expand_opcode(table, instruction, field->last + 1, - ((opcode_nr << field->width) + field->val_int), - bits); + lf_printf (file, "%s", prefix); + lf_indent (file, +1); + while (entry != NULL) + { + dump_model_data (file, "\n(", entry, ")"); + entry = entry->next; } - else { - int val; - int last_pos = ((field->last < table->opcode->last) - ? field->last : table->opcode->last); - int first_pos = ((field->first > table->opcode->first) - ? field->first : table->opcode->first); - int width = last_pos - first_pos + 1; - if (field->is_reserved) - insn_table_expand_opcode(table, instruction, last_pos + 1, - ((opcode_nr << width)), - bits); - else { - int last_val = (table->opcode->is_boolean - ? 2 : (1 << width)); - for (val = 0; val < last_val; val++) { - insn_bits *new_bits = ZALLOC(insn_bits); - new_bits->field = field; - new_bits->value = val; - new_bits->last = bits; - new_bits->opcode = table->opcode; - insn_table_expand_opcode(table, instruction, last_pos+1, - ((opcode_nr << width) | val), - new_bits); - } - } - } - } + lf_indent (file, -1); + lf_printf (file, "%s", suffix); } static void -insn_table_insert_expanding(insn_table *table, - insn *entry) +dump_model_entry (lf *file, + char *prefix, + model_entry *entry, + char *suffix) { - insn_table_expand_opcode(table, - entry, - table->opcode->first, - 0, - table->expanded_bits); + lf_printf (file, "%s(model_entry *) 0x%lx", prefix, (long) entry); + if (entry != NULL) + { + lf_indent (file, +1); + dump_line_ref (file, "\n(line ", entry->line, ")"); + dump_filter (file, "\n(flags ", entry->flags, ")"); + lf_printf (file, "\n(name \"%s\")", entry->name); + lf_printf (file, "\n(full_name \"%s\")", entry->full_name); + lf_printf (file, "\n(unit_data \"%s\")", entry->unit_data); + lf_printf (file, "\n(next 0x%lx)", (long) entry->next); + lf_indent (file, -1); + } + lf_printf (file, "%s", prefix); } - -static int -special_matches_all_insns (unsigned mask, unsigned value, insn *insns) +static void +dump_model_entries (lf *file, + char *prefix, + model_entry *entry, + char *suffix) { - insn *i; - for (i = insns; i != NULL; i = i->next) - if ((i->fields->value & mask) != value) - return 0; - return 1; + lf_printf (file, "%s", prefix); + lf_indent (file, +1); + while (entry != NULL) + { + dump_model_entry (file, "\n(", entry, ")"); + entry = entry->next; + } + lf_indent (file, -1); + lf_printf (file, "%s", suffix); } -void -insn_table_expand_insns(insn_table *table) -{ - - ASSERT(table->nr_insn >= 1); - - /* determine a valid opcode */ - while (table->opcode_rule) { - /* specials only for single instructions or normal rules when - matches all */ - if ((table->nr_insn > 1 - && table->opcode_rule->special_mask == 0 - && table->opcode_rule->type == normal_decode_rule) - || (table->nr_insn > 1 - && table->opcode_rule->special_mask != 0 - && table->opcode_rule->type == normal_decode_rule - && special_matches_all_insns (table->opcode_rule->special_mask, - table->opcode_rule->special_value, - table->insns)) - || (table->nr_insn == 1 - && table->opcode_rule->special_mask != 0 - && ((table->insns->fields->value - & table->opcode_rule->special_mask) - == table->opcode_rule->special_value)) - || (generate_expanded_instructions - && table->opcode_rule->special_mask == 0 - && table->opcode_rule->type == normal_decode_rule)) - table->opcode = - insn_table_find_opcode_field(table->insns, - table->opcode_rule, - table->nr_insn == 1/*string*/ - ); - if (table->opcode != NULL) - break; - table->opcode_rule = table->opcode_rule->next; - } - - /* did we find anything */ - if (table->opcode == NULL) { - return; - } - ASSERT(table->opcode != NULL); +static void +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) + { + lf_indent (file, +1); + dump_filter (file, "\n(processors ", entry->processors, ")"); + lf_printf (file, "\n(nr_models %d)", entry->nr_models); + dump_model_entries (file, "\n(models ", entry->models, ")"); + dump_model_datas (file, "\n(macros ", entry->macros, ")"); + dump_model_datas (file, "\n(data ", entry->data, ")"); + dump_function_entries (file, "\n(statics ", entry->statics, ")"); + dump_function_entries (file, "\n(internals ", entry->functions, ")"); + dump_function_entries (file, "\n(functions ", entry->functions, ")"); + lf_indent (file, -1); + } + lf_printf (file, "%s", suffix); +} - /* back link what we found to its parent */ - if (table->parent != NULL) { - ASSERT(table->parent->opcode != NULL); - table->opcode->parent = table->parent->opcode; - } - /* expand the raw instructions according to the opcode */ - { - insn *entry; - for (entry = table->insns; entry != NULL; entry = entry->next) { - insn_table_insert_expanding(table, entry); +static char * +insn_field_type_to_str (insn_field_type type) +{ + switch (type) + { + 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; +} - /* and do the same for the sub entries */ - { - insn_table *entry; - for (entry = table->entries; entry != NULL; entry = entry->sibling) { - insn_table_expand_insns(entry); +void +dump_insn_field (lf *file, + char *prefix, + insn_field_entry *field, + char *suffix) +{ + char *sep = " "; + lf_printf (file, "%s(insn_field_entry *) 0x%lx", prefix, (long) field); + if (field != NULL) + { + lf_indent (file, +1); + 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)); + switch (field->type) + { + case insn_field_int: + lf_printf (file, "%s(val 0x%lx)", sep, (long) field->val_int); + break; + case insn_field_reserved: + /* nothing output */ + break; + case insn_field_wild: + /* nothing output */ + break; + case insn_field_string: + lf_printf (file, "%s(val \"%s\")", sep, field->val_string); + break; + } + lf_printf (file, "%s(next 0x%lx)", sep, (long) field->next); + lf_printf (file, "%s(prev 0x%lx)", sep, (long) field->prev); + lf_indent (file, -1); } - } + lf_printf (file, "%s", suffix); } - - - -#ifdef MAIN +void +dump_insn_word_entry (lf *file, + char *prefix, + insn_word_entry *word, + char *suffix) +{ + lf_printf (file, "%s(insn_word_entry *) 0x%lx", prefix, (long) word); + if (word != NULL) + { + int i; + insn_field_entry *field; + lf_indent (file, +1); + lf_printf (file, "\n(first 0x%lx)", (long) word->first); + lf_printf (file, "\n(last 0x%lx)", (long) word->last); + 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); + lf_printf (file, ")"); + for (field = word->first; field != NULL; field = field->next) + dump_insn_field (file, "\n(", field, ")"); + dump_filter (file, "\n(field_names ", word->field_names, ")"); + lf_printf (file, "\n(next 0x%lx)", (long) word->next); + lf_indent (file, -1); + } + lf_printf (file, "%s", suffix); +} static void -dump_insn_field(insn_field *field, - int indent) +dump_insn_word_entries (lf *file, + char *prefix, + insn_word_entry *word, + char *suffix) { - - printf("(insn_field*)0x%x\n", (unsigned)field); - - dumpf(indent, "(first %d)\n", field->first); - - dumpf(indent, "(last %d)\n", field->last); - - dumpf(indent, "(width %d)\n", field->width); - - if (field->is_int) - dumpf(indent, "(is_int %d)\n", field->val_int); - - if (field->is_reserved) - dumpf(indent, "(is_wild)\n"); - - if (field->is_wild) - dumpf(indent, "(is_wild)\n"); - - if (field->is_string) - dumpf(indent, "(is_string `%s')\n", field->val_string); - - dumpf(indent, "(next 0x%x)\n", field->next); - - dumpf(indent, "(prev 0x%x)\n", field->prev); - - + lf_printf (file, "%s", prefix); + while (word != NULL) + { + dump_insn_word_entry (file, "\n(", word, ")"); + word = word->next; + } + lf_printf (file, "%s", suffix); } static void -dump_insn_fields(insn_fields *fields, - int indent) +dump_insn_model_entry (lf *file, + char *prefix, + insn_model_entry *model, + char *suffix) { - int i; - - printf("(insn_fields*)%p\n", fields); - - dumpf(indent, "(first 0x%x)\n", fields->first); - dumpf(indent, "(last 0x%x)\n", fields->last); - - dumpf(indent, "(value 0x%x)\n", fields->value); - - for (i = 0; i < insn_bit_size; i++) { - dumpf(indent, "(bits[%d] ", i, fields->bits[i]); - dump_insn_field(fields->bits[i], indent+1); - dumpf(indent, " )\n"); - } - + lf_printf (file, "%s(insn_model_entry *) 0x%lx", prefix, (long) model); + if (model != NULL) + { + lf_indent (file, +1); + dump_line_ref (file, "\n(line ", model->line, ")"); + lf_printf (file, "\n(name \"%s\")", model->name); + lf_printf (file, "\n(full_name \"%s\")", model->full_name); + lf_printf (file, "\n(unit_data \"%s\")", model->unit_data); + lf_printf (file, "\n(insn (insn_entry *) 0x%lx)", (long) model->insn); + lf_printf (file, "\n(next (insn_model_entry *) 0x%lx)", + (long) model->next); + lf_indent (file, -1); + } + lf_printf (file, "%s", suffix); } - static void -dump_opcode_field(opcode_field *field, int indent, int levels) -{ - printf("(opcode_field*)%p\n", field); - if (levels && field != NULL) { - dumpf(indent, "(first %d)\n", field->first); - dumpf(indent, "(last %d)\n", field->last); - dumpf(indent, "(is_boolean %d)\n", field->is_boolean); - dumpf(indent, "(parent "); - dump_opcode_field(field->parent, indent, levels-1); - } +dump_insn_model_entries (lf *file, + char *prefix, + insn_model_entry *model, + char *suffix) +{ + lf_printf (file, "%s", prefix); + while (model != NULL) + { + dump_insn_model_entry (file, "\n", model, ""); + model = model->next; + } + lf_printf (file, "%s", suffix); } static void -dump_insn_bits(insn_bits *bits, int indent, int levels) -{ - printf("(insn_bits*)%p\n", bits); - - if (levels && bits != NULL) { - dumpf(indent, "(value %d)\n", bits->value); - dumpf(indent, "(opcode "); - dump_opcode_field(bits->opcode, indent+1, 0); - dumpf(indent, " )\n"); - dumpf(indent, "(field "); - dump_insn_field(bits->field, indent+1); - dumpf(indent, " )\n"); - dumpf(indent, "(last "); - dump_insn_bits(bits->last, indent+1, levels-1); - } +dump_insn_mnemonic_entry (lf *file, + char *prefix, + insn_mnemonic_entry *mnemonic, + char *suffix) +{ + lf_printf (file, "%s(insn_mnemonic_entry *) 0x%lx", prefix, (long) mnemonic); + if (mnemonic != NULL) + { + lf_indent (file, +1); + dump_line_ref (file, "\n(line ", mnemonic->line, ")"); + lf_printf (file, "\n(format \"%s\")", mnemonic->format); + lf_printf (file, "\n(condition \"%s\")", mnemonic->condition); + lf_printf (file, "\n(insn (insn_entry *) 0x%lx)", + (long) mnemonic->insn); + lf_printf (file, "\n(next (insn_mnemonic_entry *) 0x%lx)", + (long) mnemonic->next); + lf_indent (file, -1); + } + lf_printf (file, "%s", suffix); } - - static void -dump_insn(insn *entry, int indent, int levels) +dump_insn_mnemonic_entries (lf *file, + char *prefix, + insn_mnemonic_entry *mnemonic, + char *suffix) { - printf("(insn*)%p\n", entry); - - if (levels && entry != NULL) { - - dumpf(indent, "(file_entry "); - dump_table_entry(entry->file_entry, indent+1); - dumpf(indent, " )\n"); - - dumpf(indent, "(fields "); - dump_insn_fields(entry->fields, indent+1); - dumpf(indent, " )\n"); - - dumpf(indent, "(next "); - dump_insn(entry->next, indent+1, levels-1); - dumpf(indent, " )\n"); + lf_printf (file, "%s", prefix); + while (mnemonic != NULL) + { + dump_insn_mnemonic_entry (file, "\n", mnemonic, ""); + mnemonic = mnemonic->next; + } + lf_printf (file, "%s", suffix); +} +void +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) + { + int i; + lf_indent (file, +1); + dump_line_ref (file, "\n(line ", entry->line, ")"); + dump_filter (file, "\n(flags ", entry->flags, ")"); + lf_printf (file, "\n(nr_words %d)", entry->nr_words); + dump_insn_word_entries (file, "\n(words ", entry->words, ")"); + lf_printf (file, "\n(word"); + for (i = 0; i < entry->nr_models; i++) + lf_printf (file, " 0x%lx", (long) entry->word[i]); + lf_printf (file, ")"); + dump_filter (file, "\n(field_names ", entry->field_names, ")"); + lf_printf (file, "\n(format_name \"%s\")", entry->format_name); + dump_filter (file, "\n(options ", entry->options, ")"); + lf_printf (file, "\n(name \"%s\")", entry->name); + lf_printf (file, "\n(nr_models %d)", entry->nr_models); + dump_insn_model_entries (file, "\n(models ", entry->models, ")"); + lf_printf (file, "\n(model"); + for (i = 0; i < entry->nr_models; i++) + 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_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_table(insn_table *table, - int indent, int levels) +dump_insn_entries (lf *file, + char *prefix, + insn_entry *entry, + char *suffix) { + lf_printf (file, "%s", prefix); + lf_indent (file, +1); + while (entry != NULL) + { + dump_insn_entry (file, "\n(", entry, ")"); + entry = entry->next; + } + lf_indent (file, -1); + lf_printf (file, "%s", suffix); +} - printf("(insn_table*)%p\n", table); - - if (levels && table != NULL) { - - dumpf(indent, "(opcode_nr %d)\n", table->opcode_nr); - - dumpf(indent, "(expanded_bits "); - dump_insn_bits(table->expanded_bits, indent+1, -1); - dumpf(indent, " )\n"); - - dumpf(indent, "(int nr_insn %d)\n", table->nr_insn); - - dumpf(indent, "(insns "); - dump_insn(table->insns, indent+1, table->nr_insn); - dumpf(indent, " )\n"); - - dumpf(indent, "(opcode_rule "); - dump_decode_rule(table->opcode_rule, indent+1); - dumpf(indent, " )\n"); - - dumpf(indent, "(opcode "); - dump_opcode_field(table->opcode, indent+1, 1); - dumpf(indent, " )\n"); - - dumpf(indent, "(nr_entries %d)\n", table->entries); - dumpf(indent, "(entries "); - dump_insn_table(table->entries, indent+1, table->nr_entries); - dumpf(indent, " )\n"); - - dumpf(indent, "(sibling ", table->sibling); - dump_insn_table(table->sibling, indent+1, levels-1); - dumpf(indent, " )\n"); - dumpf(indent, "(parent ", table->parent); - dump_insn_table(table->parent, indent+1, 0); - dumpf(indent, " )\n"); - } +void +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) + { + lf_indent (file, +1); + dump_cache_entries (file, "\n(caches ", isa->caches, ")"); + lf_printf (file, "\n(nr_insns %d)", isa->nr_insns); + lf_printf (file, "\n(max_nr_words %d)", isa->max_nr_words); + dump_insn_entries (file, "\n(insns ", isa->insns, ")"); + dump_function_entries (file, "\n(functions ", isa->functions, ")"); + dump_insn_entry (file, "\n(illegal_insn ", isa->illegal_insn, ")"); + dump_model_table (file, "\n(model ", isa->model, ")"); + dump_filter (file, "\n(flags ", isa->flags, ")"); + dump_filter (file, "\n(options ", isa->options, ")"); + lf_indent (file, -1); + } + lf_printf (file, "%s", suffix); } -int insn_bit_size = default_insn_bit_size; -int hi_bit_nr; -int generate_expanded_instructions; -int insn_specifying_widths; +#ifdef MAIN + +igen_options options; int -main(int argc, char **argv) +main (int argc, char **argv) { - filter *filters = NULL; - decode_table *decode_rules = NULL; - insn_table *instructions = NULL; + insn_table *isa; + lf *l; + + INIT_OPTIONS (options); - if (argc != 7) - error("Usage: insn \n"); + if (argc == 3) + filter_parse (&options.flags_filter, argv[2]); + else if (argc != 2) + error (NULL, "Usage: insn [ ]\n"); - filters = new_filter(argv[1], filters); - hi_bit_nr = a2i(argv[2]); - insn_bit_size = a2i(argv[3]); - insn_specifying_widths = a2i(argv[4]); - ASSERT(hi_bit_nr < insn_bit_size); - decode_rules = load_decode_table(argv[5], hi_bit_nr); - instructions = load_insn_table(argv[6], decode_rules, filters); - insn_table_expand_insns(instructions); + isa = load_insn_table (argv[1], NULL); + l = lf_open ("-", "stdout", lf_omit_references, lf_is_text, "tmp-ld-insn"); + dump_insn_table (l, "(isa ", isa, ")\n"); - dump_insn_table(instructions, 0, -1); return 0; } -- 2.7.4