Problems with conditional instruction-table fields (N!M, N=M, ...).

Was restricting `M' to opcode fields in the current word.

diff --git a/sim/igen/ChangeLog b/sim/igen/ChangeLog
index aba3321a8aab0179e136957b399d1baec03f43dd..b5f637180d8054e3fefe00c5da89b27047e5441c 100644 (file)
--- a/sim/igen/ChangeLog
+++ b/sim/igen/ChangeLog
@@ -1,3 +1,28 @@
+Tue Jul 28 11:19:43 1998  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * ld-insn.c (parse_insn_word): For constant conditional strings,
+       encode their bit value.
+
+       * ld-insn.c (parse_insn_word, parse_insn_words): Allow conditional
+       operands to refer to fields in earlier instruction words.
+
+       * gen.c (sub_val): Replace field argument with val_last_pos.
+       (gen_entry_expand_opcode): Look in previous tables for a value for
+       a conditional field as well as the bits from the current table.
+       (insn_list_insert): Add sort key of instructions where
+       their operand fields have different conditionals.
+       (insn_field_cmp): New function.
+       
+Sun Apr 26 15:31:55 1998  Tom Tromey  <tromey@creche>
+
+       * configure: Regenerated to track ../common/aclocal.m4 changes.
+       * config.in: Ditto.
+
+Sun Apr 26 15:20:08 1998  Tom Tromey  <tromey@cygnus.com>
+
+       * acconfig.h: New file.
+       * configure.in: Reverted change of Apr 24; use sinclude again.
+
 Fri Apr 24 14:16:40 1998  Tom Tromey  <tromey@creche>
 
        * configure: Regenerated to track ../common/aclocal.m4 changes.

diff --git a/sim/igen/gen.c b/sim/igen/gen.c
index f630b9f1739bbb6f0c17f6b52f089acec1020ccc..bd10f20808468fc5ee1efc262521fe52d8e645ad 100644 (file)
--- a/sim/igen/gen.c
+++ b/sim/igen/gen.c
@@ -31,11 +31,11 @@
 
 static insn_uint
 sub_val (insn_uint val,
-        insn_field_entry *field,
+        int val_last_pos,
         int first_pos,
         int last_pos)
 {
-  return ((val >> (field->last - last_pos))
+  return ((val >> (val_last_pos - last_pos))
          & (((insn_uint)1 << (last_pos - first_pos + 1)) - 1));
 }
 
@@ -107,6 +107,73 @@ print_gen_entry_insns (gen_entry *table,
     }
 }
 
+/* same as strcmp */
+static int
+insn_field_cmp (insn_word_entry *l, insn_word_entry *r)
+{
+  while (1)
+    {
+      int bit_nr;
+      if (l == NULL && r == NULL)
+       return 0; /* all previous fields the same */
+      if (l == NULL)
+       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++)
+       {
+         if (l->bit[bit_nr]->field->type != insn_field_string)
+           continue;
+         if (r->bit[bit_nr]->field->type != insn_field_string)
+           continue;
+         if (l->bit[bit_nr]->field->conditions == NULL)
+           continue;
+         if (r->bit[bit_nr]->field->conditions == NULL)
+           continue;
+         if (0)
+           printf ("%s%s%s VS %s%s%s\n",
+                   l->bit[bit_nr]->field->val_string,
+                   l->bit[bit_nr]->field->conditions->test == insn_field_cond_eq ? "=" : "!",
+                   l->bit[bit_nr]->field->conditions->string,  
+                   r->bit[bit_nr]->field->val_string,
+                   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)
+           {
+             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);
+                 if (cmp != 0)
+                   return cmp;
+                 else
+                   continue;
+               }
+             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)
+               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. */
+             continue;
+           }
+         if (l->bit[bit_nr]->field->conditions->test == insn_field_cond_eq)
+           return +1; /* left = only */
+         if (r->bit[bit_nr]->field->conditions->test == insn_field_cond_eq)
+           return -1; /* right = only */
+         /* FIXME: Need to some what arbitrarily order conditional lists */
+         continue;
+       }
+      l = l->next;
+      r = r->next;
+    }
+}
 
 /* same as strcmp */
 static int
@@ -139,6 +206,7 @@ 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)
@@ -172,6 +240,8 @@ opcode_bit_cmp (opcode_bits *l,
   return 0;
 }
 
+
+/* same as strcmp */
 static int
 opcode_bits_cmp (opcode_bits *l,
                 opcode_bits *r)
@@ -189,6 +259,7 @@ opcode_bits_cmp (opcode_bits *l,
     }
 }
 
+/* same as strcmp */
 static opcode_bits *
 new_opcode_bits (opcode_bits *old_bits,
                 int value,
@@ -255,57 +326,59 @@ insn_list_insert (insn_list **cur_insn_ptr,
                  duplicate_insn_actions duplicate_action)
 {
   /* insert it according to the order of the fields & bits */
-  while ((*cur_insn_ptr) != NULL)
+  for (; (*cur_insn_ptr) != NULL; cur_insn_ptr = &(*cur_insn_ptr)->next)
     {
-      int word_cmp = insn_word_cmp (insn->words,
-                                   (*cur_insn_ptr)->insn->words);
-      if (word_cmp < 0)
-       {
-         /* found insertion point - new_insn < cur_insn->next */
-         break;
-       }
-      else if (word_cmp == 0)
+      int cmp;
+
+      /* key#1 sort according to the constant fields of each instruction */
+      cmp = insn_word_cmp (insn->words, (*cur_insn_ptr)->insn->words);
+      if (cmp < 0)
+       break;
+      else if (cmp > 0)
+       continue;
+
+      /* key#2 sort according to the expanded bits of each instruction */
+      cmp = opcode_bits_cmp (expanded_bits, (*cur_insn_ptr)->expanded_bits);
+      if (cmp < 0)
+       break;
+      else if (cmp > 0)
+       continue;
+
+      /* key#3 sort according to the non-constant fields of each instruction */
+      cmp = insn_field_cmp (insn->words, (*cur_insn_ptr)->insn->words);
+      if (cmp < 0)
+       break;
+      else if (cmp > 0)
+       continue;
+
+      /* duplicate keys, report problem */
+      switch (duplicate_action)
        {
-         /* words same, try for bit fields */
-         int bit_cmp = opcode_bits_cmp (expanded_bits,
-                                        (*cur_insn_ptr)->expanded_bits);
-         if (bit_cmp < 0)
-           {
-             /* found insertion point - new_insn < cur_insn->next */
-             break;
-           }
-         else if (bit_cmp == 0)
+       case report_duplicate_insns:
+         /* two instructions with the same constant field
+            values across all words and bits */
+         warning (insn->line,
+                  "Two instructions with identical constant fields\n");
+         error ((*cur_insn_ptr)->insn->line,
+                "Location of second (duplicated?) instruction\n");
+       case merge_duplicate_insns:
+         /* Add the opcode path to the instructions list */
+         if (opcodes != NULL)
            {
-             switch (duplicate_action)
+             insn_opcodes **last = &(*cur_insn_ptr)->opcodes;
+             while (*last != NULL)
                {
-               case report_duplicate_insns:
-                 /* two instructions with the same constant field
-                    values across all words and bits */
-                 warning (insn->line,
-                          "Two instructions with identical constant fields\n");
-                 error ((*cur_insn_ptr)->insn->line,
-                        "Location of second (duplicated?) instruction\n");
-               case merge_duplicate_insns:
-                 /* Add the opcode path to the instructions list */
-                 if (opcodes != NULL)
-                   {
-                     insn_opcodes **last = &(*cur_insn_ptr)->opcodes;
-                     while (*last != NULL)
-                       {
-                         last = &(*last)->next;
-                       }
-                     (*last) = ZALLOC (insn_opcodes);
-                     (*last)->opcode = opcodes;
-                   }
-                 /* Use the larger nr_prefetched_words */
-                 if ((*cur_insn_ptr)->nr_prefetched_words < nr_prefetched_words)
-                   (*cur_insn_ptr)->nr_prefetched_words = nr_prefetched_words;
-                 return (*cur_insn_ptr);
+                 last = &(*last)->next;
                }
+             (*last) = ZALLOC (insn_opcodes);
+             (*last)->opcode = opcodes;
            }
+         /* Use the larger nr_prefetched_words */
+         if ((*cur_insn_ptr)->nr_prefetched_words < nr_prefetched_words)
+           (*cur_insn_ptr)->nr_prefetched_words = nr_prefetched_words;
+         return (*cur_insn_ptr);
        }
-      /* keep looking - new_insn > cur_insn->next */
-      cur_insn_ptr = &(*cur_insn_ptr)->next;
+
     }
   
   /* create a new list entry and insert it */
@@ -591,22 +664,21 @@ insns_bit_useless (insn_list *insns,
                           condition != NULL;
                           condition = condition->next)
                        {
-                       printf ("useless %s%s\n",
-                               (condition->type == insn_field_cond_eq ? "=" : "!"),
-                               condition->string);
                          switch (condition->type)
                            {
                            case insn_field_cond_value:
                              switch (condition->test)
                                {
                                case insn_field_cond_ne:
-                                 if (((condition->value >> shift) & 1) == value)
+                                 if (((condition->value >> shift) & 1)
+                                     == (unsigned) value)
                                    /* conditional field excludes the
                                        current value */
                                    is_useless = 0;
                                  break;
                                case insn_field_cond_eq:
-                                 if (((condition->value >> shift) & 1) != value)
+                                 if (((condition->value >> shift) & 1)
+                                     != (unsigned) value)
                                    /* conditional field requires the
                                        current value */
                                    is_useless = 0;
@@ -853,10 +925,6 @@ gen_entry_expand_opcode (gen_entry *table,
        }
       else
        {
-         if (options.trace.insn_insertion)
-           {
-             
-           }
          gen_entry_insert_insn (table, instruction,
                                 table->opcode->word_nr,
                                 table->nr_prefetched_words,
@@ -879,7 +947,8 @@ gen_entry_expand_opcode (gen_entry *table,
        case insn_field_int:
          {
            int val;
-           val = sub_val (field->val_int, field, 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),
@@ -913,7 +982,7 @@ gen_entry_expand_opcode (gen_entry *table,
                          {
                          case insn_field_cond_value:
                            {
-                             int value = sub_val (condition->value, field,
+                             int value = sub_val (condition->value, field->last,
                                                   first_pos, last_pos);
                              switch (condition->test)
                                {
@@ -931,27 +1000,51 @@ gen_entry_expand_opcode (gen_entry *table,
                          case insn_field_cond_field:
                            {
                              int value;
-                             /* Find a value for the conditional by
-                                 looking back through the previously
-                                 defined bits for the specified
-                                 conditonal field */
-                             opcode_bits *bit = bits;
+                             opcode_bits *bit;
+                             gen_entry *t;
+                             /* Try to find a value for the
+                                 conditional by looking back through
+                                 the previously defined bits for the
+                                 specified conditional field */
                              for (bit = bits;
                                   bit != NULL;
                                   bit = bit->next)
                                {
                                  if (bit->field == condition->field
                                      && (bit->last - bit->first + 1 == condition->field->width))
-                                   /* the bit field fully specified
-                                       the conditional field's value */
-                                   break;
+                                   {
+                                     /* the bit field fully specified
+                                        the conditional field's value */
+                                     value = sub_val (bit->value, bit->last,
+                                                      first_pos, last_pos);
+                                     break;
+                                   }
                                }
+                             /* Try to find a value by looking
+                                 through this and previous tables */
                              if (bit == NULL)
+                               {
+                                 for (t = table;
+                                      t->parent != NULL;
+                                      t = t->parent)
+                                   {
+                                     if (t->parent->opcode->word_nr != condition->field->word_nr)
+                                       continue;
+                                     if (t->parent->opcode->first <= condition->field->first
+                                         && t->parent->opcode->last >= condition->field->last)
+                                       {
+                                         /* the table entry fully
+                                             specified the condition
+                                             field's value */
+                                         value = sub_val (t->opcode_nr, t->parent->opcode->last,
+                                                          first_pos, last_pos);
+                                       }
+                                   }
+                               }
+                             if (bit == NULL && t == NULL)
                                error (instruction->line,
                                       "Conditional `%s' of field `%s' isn't expanded",
                                       condition->string, field->val_string);
-                             value = sub_val (bit->value, field,
-                                              first_pos, last_pos);
                              switch (condition->test)
                                {
                                case insn_field_cond_ne: