Added more stuff to xsthammer, found first xst bug

diff --git a/tests/xsthammer/generate.cc b/tests/xsthammer/generate.cc
index 7af084be585851af256060f2e398501b751d9c52..672ad86a1a31f08e929cef95461c5744277e0a0c 100644 (file)
--- a/tests/xsthammer/generate.cc
+++ b/tests/xsthammer/generate.cc
@@ -3,10 +3,13 @@
 #define GENERATE_UNARY_OPS
 #define GENERATE_TERNARY_OPS
 #define GENERATE_CONCAT_OPS
+#undef  GENERATE_REPEAT_OPS  // disabled because of XST bug
+#undef  GENERATE_EXPRESSIONS
 
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <string.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <string>
 
@@ -78,6 +81,79 @@ void strsubst(std::string &str, const std::string &match, const std::string &rep
                str.replace(pos, match.size(), replace);
 }
 
+uint32_t xorshift32(uint32_t seed = 0) {
+       static uint32_t x = 314159265;
+       if (seed)
+               x = seed;
+       x ^= x << 13;
+       x ^= x >> 17;
+       x ^= x << 5;
+       return x;
+}
+
+void print_expression(FILE *f, int budget, uint32_t mask = 0)
+{
+       size_t num_binary_ops = sizeof(binary_ops)/sizeof(*binary_ops);
+       size_t num_unary_ops = sizeof(unary_ops)/sizeof(*unary_ops);
+       size_t num_arg_types = sizeof(arg_types)/sizeof(*arg_types);
+       int i, j, k, mode;
+
+       if (budget == 0) {
+               fprintf(f, "%c%d", 'a' + char(xorshift32() % 2), int(xorshift32() % num_arg_types));
+               return;
+       }
+
+       int num_modes = 4;
+       while ((mask & ~((~0) << num_modes)) == 0)
+               mask = xorshift32();
+       do {
+               mode = xorshift32() % num_modes;
+       } while (((1 << mode) & mask) == 0);
+
+       fprintf(f, "/* %d */", mode);
+
+       budget--;
+       switch (mode)
+       {
+       case 0:
+               fprintf(f, "(");
+               print_expression(f, budget, mask);
+               fprintf(f, ")");
+               break;
+       case 1:
+               fprintf(f, "(");
+               print_expression(f, budget/2, mask);
+               fprintf(f, "%s", binary_ops[xorshift32() % num_binary_ops]);
+               print_expression(f, budget/2, mask);
+               fprintf(f, ")");
+               break;
+       case 2:
+               fprintf(f, "(%s", unary_ops[xorshift32() % num_unary_ops]);
+               print_expression(f, budget, mask);
+               fprintf(f, ")");
+               break;
+       case 3:
+               i = 1 + xorshift32() % 3;
+               fprintf(f, "{");
+               for (j = 0; j < i; j++) {
+                       if (j)
+                               fprintf(f, ",");
+                       print_expression(f, budget / i, mask);
+               }
+               fprintf(f, "}");
+               break;
+#if 0
+               // FIXME: disabled because there is an xst bug..
+       case 4:
+               i = xorshift32() % 4;
+               fprintf(f, "{%d{", i);
+               print_expression(f, budget, mask);
+               fprintf(f, "}}");
+               break;
+#endif
+       }
+}
+
 int main()
 {
        mkdir("rtl", 0777);
@@ -268,6 +344,101 @@ int main()
        }
 #endif
 
+#ifdef GENERATE_REPEAT_OPS
+       for (int a = 0; a < 4; a++)
+       for (int bi = 0; bi < sizeof(small_arg_types)/sizeof(small_arg_types[0]); bi++)
+       for (int yi = 0; yi < sizeof(arg_types)/sizeof(arg_types[0]); yi++)
+       {
+               std::string b_decl = small_arg_types[bi][0];
+               strsubst(b_decl, "{dir}", "input");
+               strsubst(b_decl, "{name}", "b");
+
+               std::string y_decl = arg_types[yi][0];
+               strsubst(y_decl, "{dir}", "output");
+               strsubst(y_decl, "{name}", "y");
+
+               std::string b_ref = small_arg_types[bi][1];
+               strsubst(b_ref, "{dir}", "input");
+               strsubst(b_ref, "{name}", "b");
+
+               std::string y_ref = arg_types[yi][1];
+               strsubst(y_ref, "{dir}", "output");
+               strsubst(y_ref, "{name}", "y");
+
+               char buffer[1024];
+               snprintf(buffer, 1024, "rtl/repeat_ops_%02d%02d%02d.v", a, bi, yi);
+
+               FILE *f = fopen(buffer, "w");
+               fprintf(f, "module repeat_ops_%02d%02d%02d(a, b, y);\n", a, bi, yi);
+               fprintf(f, "input a;\n");
+               fprintf(f, "%s;\n", b_decl.c_str());
+               fprintf(f, "%s;\n", y_decl.c_str());
+               fprintf(f, "assign %s = {%d{%s}};\n", y_ref.c_str(), a, b_ref.c_str());
+               fprintf(f, "endmodule\n");
+               fclose(f);
+       }
+#endif
+
+#ifdef GENERATE_EXPRESSIONS
+       for (int i = 0; i < 1000; i++)
+       {
+               xorshift32(1234 + i);
+               xorshift32();
+               xorshift32();
+               xorshift32();
+
+               char buffer[1024];
+               snprintf(buffer, 1024, "rtl/expression_%05d.v", i);
+
+               FILE *f = fopen(buffer, "w");
+               fprintf(f, "module expression_%05d(a, b, y);\n", i);
+
+               for (char var = 'a'; var <= 'y'; var++)
+               {
+                       fprintf(f, "%s [", var != 'y' ? "input" : "output");
+                       for (int j = 0; j < sizeof(arg_types)/sizeof(arg_types[0]); j++)
+                               fprintf(f, "%s%s", j ? "+" : "", arg_types[j][2]);
+                       fprintf(f, "-1:0] %c;\n", var);
+
+                       for (int j = 0; j < sizeof(arg_types)/sizeof(arg_types[0]); j++)
+                       {
+                               std::string decl = arg_types[j][0];
+                               strsubst(decl, "{dir}", "wire");
+                               snprintf(buffer, 1024, "%c%d", var, j);
+                               strsubst(decl, "{name}", buffer);
+
+                               if (var != 'y') {
+                                       fprintf(f, "%s = %c[", decl.c_str(), var);
+                                       for (int k = 0; k <= j; k++)
+                                               fprintf(f, "%s%s", k ? "+" : "", arg_types[k][2]);
+                                       fprintf(f, "-1:");
+                                       for (int k = 0; k < j; k++)
+                                               fprintf(f, "%s%s", k ? "+" : "", arg_types[k][2]);
+                                       fprintf(f, "%s];\n", j ? "" : "0");
+                               } else
+                                       fprintf(f, "%s;\n", decl.c_str());
+                       }
+
+                       if (var == 'b')
+                               var = 'x';
+               }
+
+               fprintf(f, "assign y = {");
+               for (int j = 0; j < sizeof(arg_types)/sizeof(arg_types[0]); j++)
+                       fprintf(f, "%sy%d", j ? "," : "", j);
+               fprintf(f, "};\n");
+
+               for (int j = 0; j < sizeof(arg_types)/sizeof(arg_types[0]); j++) {
+                       fprintf(f, "assign y%d = ", j);
+                       print_expression(f, 1 + xorshift32() % 20);
+                       fprintf(f, ";\n");
+               }
+
+               fprintf(f, "endmodule\n");
+               fclose(f);
+       }
+#endif
+
        return 0;
 }
 

diff --git a/tests/xsthammer/run-check.sh b/tests/xsthammer/run-check.sh
index 709eff8169d7a2297cf87c342a6f924fcc15f348..ee995c900eba9a7ee676e97b8bff39b215047940 100644 (file)
--- a/tests/xsthammer/run-check.sh
+++ b/tests/xsthammer/run-check.sh
@@ -53,8 +53,10 @@ done
        echo "read_ilang ${job}_top_techmap.il"
        echo "sat -verify -show a,b,y_rtl,y_xst -prove y_rtl y_xst ${job}_top_nomap"
        echo "sat -verify -show a,b,y_rtl,y_xst -prove y_rtl y_xst ${job}_top_techmap"
-       echo "sat -brute_force_equiv_checker ${job}_rtl_nomap   ${job}_xst_nomap"
-       echo "sat -brute_force_equiv_checker ${job}_rtl_techmap ${job}_xst_techmap"
+       if [[ $job != expression_* ]]; then
+               echo "sat -brute_force_equiv_checker ${job}_rtl_nomap   ${job}_xst_nomap"
+               echo "sat -brute_force_equiv_checker ${job}_rtl_techmap ${job}_xst_techmap"
+       fi
 } > ${job}_cmp.ys
 
 if ../../../../yosys -l ${job}.log ${job}_cmp.ys; then