sym-exec v13 - Some code refactored - Fixed memory leaks - Added checks for return...

diff --git a/gcc/sym-exec/condition.cc b/gcc/sym-exec/condition.cc
index eb4ecf908be182def83050af82289ebc6568d188..39d9d9eddf39e74cb05cb0135e6b70a47474a949 100644 (file)
--- a/gcc/sym-exec/condition.cc
+++ b/gcc/sym-exec/condition.cc
@@ -1,47 +1,25 @@
 #include "condition.h"
 
-bit_condition::bit_condition (value_bit *left, value_bit *right, tree_code type)
+bit_condition::bit_condition (value_bit *left, value_bit *right, tree_code code)
 {
   this->left = left;
   this->right = right;
-  this->type = type;
-
-  switch (this->type)
-    {
-      case GT_EXPR:
-       op_sign[0] = '>';
-       op_sign[1] = '\0';
-       break;
-      case LT_EXPR:
-       op_sign[0] = '<';
-       op_sign[1] = '\0';
-       break;
-      case EQ_EXPR:
-       op_sign[0] = '=';
-       op_sign[1] = '=';
-       break;
-      case NE_EXPR:
-       op_sign[0] = '!';
-       op_sign[1] = '=';
-       break;
-      default:
-       op_sign[0] = '\0';
-       op_sign[1] = '\0';
-    }
+  this->code = code;
+  type = BIT_CONDITION;
 }
 
 
 bit_condition::bit_condition (const bit_condition &expr)
 {
   bit_expression::copy (&expr);
-  type = expr.get_code ();
+  code = expr.get_code ();
 }
 
 
 tree_code
 bit_condition::get_code () const
 {
-  return type;
+  return code;
 }
 
 
@@ -52,8 +30,24 @@ bit_condition::copy () const
 }
 
 
-value_type
-bit_condition::get_type () const
+void
+bit_condition::print_expr_sign ()
 {
-  return value_type::BIT_CONDITION;
+  switch (code)
+    {
+      case GT_EXPR:
+       fprintf (dump_file, " > ");
+       break;
+      case LT_EXPR:
+       fprintf (dump_file, " < ");
+       break;
+      case EQ_EXPR:
+       fprintf (dump_file, " == ");
+       break;
+      case NE_EXPR:
+       fprintf (dump_file, " != ");
+       break;
+      default:
+       fprintf (dump_file, " ? ");
+    }
 }
\ No newline at end of file

diff --git a/gcc/sym-exec/condition.h b/gcc/sym-exec/condition.h
index 85d5938009c66deb93bca9565251243475b8733d..dc3ec382d2fbfe3ac25648c1b9b38fc7d28233e8 100644 (file)
--- a/gcc/sym-exec/condition.h
+++ b/gcc/sym-exec/condition.h
@@ -13,14 +13,14 @@ enum condition_status {
 
 class bit_condition : public bit_expression {
  private:
-  tree_code type;
+  tree_code code;
+  void print_expr_sign ();
 
  public:
   bit_condition (value_bit *left, value_bit *right, tree_code type);
   bit_condition (const bit_condition &expr);
   tree_code get_code () const;
   value_bit *copy () const;
-  value_type get_type () const;
 };
 
 #endif /* SYM_EXEC_CONDITION_H.  */
\ No newline at end of file

diff --git a/gcc/sym-exec/expression.cc b/gcc/sym-exec/expression.cc
index a21d0d69902b9c622fcd27a45b7c5769caae3ef2..7a830eb437aadfaa5fb358ecbb8547e08c08120d 100644 (file)
--- a/gcc/sym-exec/expression.cc
+++ b/gcc/sym-exec/expression.cc
@@ -4,6 +4,25 @@
 
 #include "expression-is-a-helper.h"
 
+value_type
+value_bit::get_type () const
+{
+  return type;
+}
+
+
+symbolic_bit::symbolic_bit (size_t i, tree orig) : value_bit (i), origin (orig)
+{
+  type = SYMBOLIC_BIT;
+}
+
+
+bit::bit (unsigned char i) : val (i)
+{
+  type = BIT;
+}
+
+
 value_bit *
 bit_expression::get_left ()
 {
@@ -57,8 +76,7 @@ bit_complement_expression::bit_complement_expression (value_bit *right)
 {
   this->left = nullptr;
   this->right = right;
-  op_sign[0] = '!';
-  op_sign[1] = '\0';
+  type = BIT_COMPLEMENT_EXPRESSION;
 }
 
 
@@ -101,8 +119,7 @@ bit_expression::copy (const bit_expression *expr)
   if (expr->right)
     right = expr->right->copy ();
 
-  op_sign[0] = (expr->op_sign)[0];
-  op_sign[1] = (expr->op_sign)[1];
+  type = expr->type;
 }
 
 
@@ -166,8 +183,7 @@ bit_xor_expression::bit_xor_expression (value_bit *left, value_bit *right)
 {
   this->left = left;
   this->right = right;
-  op_sign[0] = '^';
-  op_sign[1] = '\0';
+  type = BIT_XOR_EXPRESSION;
 }
 
 
@@ -181,8 +197,7 @@ bit_and_expression::bit_and_expression (value_bit *left, value_bit *right)
 {
   this->left = left;
   this->right = right;
-  op_sign[0] = '&';
-  op_sign[1] = '\0';
+  type = BIT_AND_EXPRESSION;
 }
 
 
@@ -196,8 +211,7 @@ bit_or_expression::bit_or_expression (value_bit *left, value_bit *right)
 {
   this->left = left;
   this->right = right;
-  op_sign[0] = '|';
-  op_sign[1] = '\0';
+  type = BIT_OR_EXPRESSION;
 }
 
 
@@ -212,8 +226,7 @@ shift_right_expression::shift_right_expression (value_bit *left,
 {
   this->left = left;
   this->right = right;
-  op_sign[0] = '>';
-  op_sign[1] = '>';
+  type = SHIFT_RIGHT_EXPRESSION;
 }
 
 
@@ -228,8 +241,7 @@ shift_left_expression::shift_left_expression (value_bit *left, value_bit *right)
 {
   this->left = left;
   this->right = right;
-  op_sign[0] = '<';
-  op_sign[1] = '<';
+  type = SHIFT_LEFT_EXPRESSION;
 }
 
 
@@ -243,8 +255,7 @@ add_expression::add_expression (value_bit *left, value_bit *right)
 {
   this->left = left;
   this->right = right;
-  op_sign[0] = '+';
-  op_sign[1] = '\0';
+  type = ADD_EXPRESSION;
 }
 
 
@@ -258,8 +269,7 @@ sub_expression::sub_expression (value_bit *left, value_bit *right)
 {
   this->left = left;
   this->right = right;
-  op_sign[0] = '-';
-  op_sign[1] = '\0';
+  type = SUB_EXPRESSION;
 }
 
 
@@ -269,76 +279,6 @@ sub_expression::sub_expression (const sub_expression &expr)
 }
 
 
-value_type
-symbolic_bit::get_type () const
-{
-  return value_type::SYMBOLIC_BIT;
-}
-
-
-value_type
-bit::get_type () const
-{
-  return value_type::BIT;
-}
-
-
-value_type
-bit_and_expression::get_type () const
-{
-  return value_type::BIT_AND_EXPRESSION;
-}
-
-
-value_type
-bit_or_expression::get_type () const
-{
-  return value_type::BIT_OR_EXPRESSION;
-}
-
-
-value_type
-bit_xor_expression::get_type () const
-{
-  return value_type::BIT_XOR_EXPRESSION;
-}
-
-
-value_type
-bit_complement_expression::get_type () const
-{
-  return value_type::BIT_COMPLEMENT_EXPRESSION;
-}
-
-
-value_type
-shift_left_expression::get_type () const
-{
-  return value_type::SHIFT_LEFT_EXPRESSION;
-}
-
-
-value_type
-shift_right_expression::get_type () const
-{
-  return value_type::SHIFT_RIGHT_EXPRESSION;
-}
-
-
-value_type
-add_expression::get_type () const
-{
-  return value_type::ADD_EXPRESSION;
-}
-
-
-value_type
-sub_expression::get_type () const
-{
-  return value_type::SUB_EXPRESSION;
-}
-
-
 tree
 symbolic_bit::get_origin ()
 {
@@ -365,6 +305,38 @@ bit::print ()
 }
 
 
+void
+bit_expression::print_expr_sign ()
+{
+  switch (type)
+    {
+      case BIT_XOR_EXPRESSION:
+       fprintf (dump_file, " ^ ");
+       break;
+      case BIT_AND_EXPRESSION:
+       fprintf (dump_file, " & ");
+       break;
+      case BIT_OR_EXPRESSION:
+       fprintf (dump_file, " | ");
+       break;
+      case SHIFT_RIGHT_EXPRESSION:
+       fprintf (dump_file, " >> ");
+       break;
+      case SHIFT_LEFT_EXPRESSION:
+       fprintf (dump_file, " << ");
+       break;
+      case ADD_EXPRESSION:
+       fprintf (dump_file, " + ");
+       break;
+      case SUB_EXPRESSION:
+       fprintf (dump_file, " - ");
+       break;
+      default:
+       fprintf (dump_file, " ?? ");
+    }
+}
+
+
 void
 bit_expression::print ()
 {
@@ -376,7 +348,7 @@ bit_expression::print ()
       else
        fprintf (dump_file, "null");
 
-      fprintf (dump_file, " %.2s ", op_sign);
+      print_expr_sign ();
 
       if (right)
        right->print ();
@@ -393,7 +365,7 @@ bit_complement_expression::print ()
 {
   if (dump_file)
     {
-      fprintf (dump_file, "%.2s", op_sign);
+      fprintf (dump_file, "!");
       if (right)
        right->print ();
       else

diff --git a/gcc/sym-exec/expression.h b/gcc/sym-exec/expression.h
index d81e45983922ae8856b85b7458cacfbce11e1494..10b501e782bf949cdc83983bd0d3f940d05f8fda 100644 (file)
--- a/gcc/sym-exec/expression.h
+++ b/gcc/sym-exec/expression.h
@@ -39,6 +39,7 @@ class value_bit {
   /* This will help us to understand where is moved the bit
      from its initial position.  */
   const size_t index;
+  value_type type;
 
  public:
   value_bit () : index (0)
@@ -48,10 +49,10 @@ class value_bit {
   value_bit (const value_bit &val) : index (val.index)
   {};
   size_t get_index () const;
+  value_type get_type () const;
 
   /* This will support deep copy of objects' values.  */
   virtual value_bit *copy () const = 0;
-  virtual value_type get_type () const = 0;
   virtual void print () = 0;
   virtual ~value_bit () = default;
 };
@@ -62,15 +63,13 @@ class symbolic_bit : public value_bit {
   tree origin = nullptr;
 
  public:
-  symbolic_bit (size_t i, tree orig) : value_bit (i), origin (orig)
-  {};
+  symbolic_bit (size_t i, tree orig);
   symbolic_bit (const symbolic_bit &sym_bit) : symbolic_bit (sym_bit.index,
                                                             sym_bit.origin)
   {};
 
   value_bit *copy () const;
   void print ();
-  value_type get_type () const;
   tree get_origin ();
 };
 
@@ -83,14 +82,12 @@ class bit : public value_bit {
   unsigned char val = 0;
 
  public:
-  bit (unsigned char i) : val (i)
-  {};
+  bit (unsigned char i);
   bit (const bit &b) : bit (b.val)
   {};
   unsigned char get_val () const;
   void set_val (unsigned char new_val);
   value_bit *copy () const;
-  value_type get_type () const;
   void print ();
 };
 
@@ -102,9 +99,9 @@ class bit_expression : public value_bit {
  protected:
   value_bit *left = nullptr;
   value_bit *right = nullptr;
-  char op_sign[2];
 
   void copy (const bit_expression *expr);
+  virtual void print_expr_sign ();
 
  public:
   value_bit *get_left ();
@@ -115,7 +112,6 @@ class bit_expression : public value_bit {
   void set_left (value_bit *expr);
   void set_right (value_bit *expr);
   value_bit *copy () const = 0;
-  value_type get_type () const = 0;
   void print ();
 };
 
@@ -129,7 +125,6 @@ class bit_xor_expression : public bit_expression {
   bit_xor_expression (value_bit *left, value_bit *right);
   bit_xor_expression (const bit_xor_expression &expr);
   value_bit *copy () const;
-  value_type get_type () const;
 };
 
 
@@ -142,7 +137,6 @@ class bit_and_expression : public bit_expression {
   bit_and_expression (value_bit *left, value_bit *right);
   bit_and_expression (const bit_and_expression &expr);
   value_bit *copy () const;
-  value_type get_type () const;
 };
 
 
@@ -155,7 +149,6 @@ class bit_or_expression : public bit_expression {
   bit_or_expression (value_bit *left, value_bit *right);
   bit_or_expression (const bit_or_expression &expr);
   value_bit *copy () const;
-  value_type get_type () const;
 };
 
 
@@ -166,7 +159,6 @@ class shift_right_expression : public bit_expression {
   shift_right_expression (value_bit *left, value_bit *right);
   shift_right_expression (const shift_right_expression &expr);
   value_bit *copy () const;
-  value_type get_type () const;
 };
 
 
@@ -177,7 +169,6 @@ class shift_left_expression : public bit_expression {
   shift_left_expression (value_bit *left, value_bit *right);
   shift_left_expression (const shift_left_expression &expr);
   value_bit *copy () const;
-  value_type get_type () const;
 };
 
 
@@ -188,7 +179,6 @@ class add_expression : public bit_expression {
   add_expression (value_bit *left, value_bit *right);
   add_expression (const add_expression &expr);
   value_bit *copy () const;
-  value_type get_type () const;
 };
 
 
@@ -199,7 +189,6 @@ class sub_expression : public bit_expression {
   sub_expression (value_bit *left, value_bit *right);
   sub_expression (const sub_expression &expr);
   value_bit *copy () const;
-  value_type get_type () const;
 };
 
 /* Bit-level negation expression.  */
@@ -209,7 +198,6 @@ class bit_complement_expression : public bit_expression {
   bit_complement_expression (value_bit *right);
   bit_complement_expression (const bit_complement_expression &expr);
   value_bit *copy () const;
-  value_type get_type () const;
   void print ();
 };
 

diff --git a/gcc/sym-exec/state.cc b/gcc/sym-exec/state.cc
index 15b74ce8bdf47d22797536e23458c54c1b15f93e..1dc685a85ab14e10889b27838fed631ceba05cfc 100644 (file)
--- a/gcc/sym-exec/state.cc
+++ b/gcc/sym-exec/state.cc
@@ -4,7 +4,6 @@
 
 #include "state.h"
 
-
 size_t min (size_t a, size_t b, size_t c)
 {
   size_t min = (a < b ? a : b);
@@ -30,7 +29,6 @@ state::state (const state &s)
 
 state::~state ()
 {
-  clear_var_states ();
   clear_conditions ();
 }
 
@@ -114,29 +112,6 @@ state::create_val_for_const (tree var, size_t size)
 }
 
 
-/* Removes given value.  */
-
-void
-state::free_val (value *val)
-{
-  free_bits (&val->number);
-}
-
-
-void
-state::free_bits (vec<value_bit *> *bits)
-{
-  if (bits == nullptr || !bits->exists ())
-    return;
-
-  for (size_t i = 0; i < bits->length (); i++)
-    {
-      delete (*bits)[i];
-      (*bits)[i] = nullptr;
-    }
-}
-
-
 bool
 state::add_var_state (tree var, value *vstate)
 {
@@ -145,7 +120,6 @@ state::add_var_state (tree var, value *vstate)
   for (size_t i = 0; i < size; i++)
     val.push ((*vstate)[i]->copy ());
 
-  free_val (var_states.get (var));
   return var_states.put (var, val);
 }
 
@@ -183,12 +157,6 @@ state::clear_states (vec<state *> *states)
 void
 state::clear_var_states ()
 {
-  for (auto iter = var_states.begin (); iter != var_states.end (); ++iter)
-    {
-      value *var = &(*iter).second;
-      for (size_t i = 0; i < var->length (); i++)
-       delete (*var)[i];
-    }
   var_states.empty ();
 }
 
@@ -389,9 +357,6 @@ state::do_binary_operation (tree arg1, tree arg2, tree dest,
     }
 
   (this->*bin_func) (arg1_val, arg2_val, dest);
-  free_val (&arg1_const_val);
-  free_val (&arg2_const_val);
-
   print_value (var_states.get (dest));
   return true;
 }
@@ -587,7 +552,7 @@ state::do_shift_left (value *arg1, value *arg2, tree dest)
       for (size_t i = 0; i < get_var_size (dest); i++)
        {
          delete (*var_states.get (dest))[i];
-         (*var_states.get (dest))[i] = (*result)[i];
+         (*var_states.get (dest))[i] = (*result)[i]->copy ();
        }
       delete result;
     }
@@ -615,8 +580,10 @@ state::do_shift_right (value *arg1, value *arg2, tree dest)
       for (size_t i = 0; i < get_var_size (dest); i++)
        {
          delete (*var_states.get (dest))[i];
-         (*var_states.get (dest))[i] = (*result)[i];
+         (*var_states.get (dest))[i] = (*result)[i]->copy ();
        }
+
+      delete result;
     }
   else
     operate (arg1, arg2, nullptr, dest, &state::shift_right_sym_bits);
@@ -675,20 +642,23 @@ state::additive_inverse (const value *number)
 
   size_t size = number->length ();
   one.push (new bit (1));
-  result->push (complement_a_bit ((*number)[0]->copy ()));
+  result->push (complement_a_bit ((*number)[0]));
 
   for (size_t i = 1; i < size; i++)
     {
       one.push (new bit (0));
-      result->push (complement_a_bit ((*number)[i]->copy ()));
+      result->push (complement_a_bit ((*number)[i]));
     }
 
   value_bit *carry = new bit (0);
   for (size_t i = 0; i < size; ++i)
-    (*result)[i] = full_adder ((*result)[i], one[i], &carry);
+    {
+      value_bit *cur_bit = (*result)[i];
+      (*result)[i] = full_adder (cur_bit, one[i], &carry);
+      delete cur_bit;
+    }
 
   delete carry;
-  free_val (&one);
   return result;
 }
 
@@ -707,7 +677,6 @@ state::do_sub (value *arg1, value *arg2, tree dest)
 {
   value *neg_arg2 = additive_inverse (arg2);
   do_add (arg1, neg_arg2, dest);
-  free_val (neg_arg2);
   delete neg_arg2;
 }
 
@@ -718,9 +687,8 @@ value_bit *
 state::complement_a_bit (value_bit *var)
 {
   value_bit *result = nullptr;
-  bit *const_bit = dyn_cast<bit *> (var);
-  if (const_bit)
-    result = complement_const_bit (const_bit);
+  if (is_a<bit *> (var))
+    result = complement_const_bit (as_a<bit *> (var));
   else
     result = complement_sym_bit (var);
 
@@ -758,7 +726,8 @@ state::do_complement (tree arg, tree dest)
   for (; i < get_var_size (dest); i++)
     {
       delete (*var_states.get (dest))[i];
-      (*var_states.get (dest))[i] = complement_a_bit (new bit (0));
+      bit tmp (0);
+      (*var_states.get (dest))[i] = complement_a_bit (&tmp);
     }
 
   print_value (var_states.get (dest));
@@ -797,7 +766,7 @@ state::do_assign (tree arg, tree dest)
       for (size_t i = 0; i < dest_val->length (); i++)
        {
          delete (*dest_val)[i];
-         (*dest_val)[i] = arg_val[i];
+         (*dest_val)[i] = arg_val[i]->copy ();
        }
     }
   else
@@ -836,7 +805,7 @@ state::do_assign_pow2 (tree dest, unsigned pow)
       dest_val = var_states.get (dest);
     }
   else
-    free_val (dest_val);
+    dest_val->free_bits ();
 
   for (unsigned i = 0; i < dest_val->length (); i++)
     {
@@ -971,14 +940,15 @@ state::xor_const_bits (const bit *const_bit1, const bit *const_bit2)
 value_bit *
 state::xor_var_const (const value_bit *var, const bit *const_bit)
 {
+  if (const_bit->get_val () == 0)
+    return var->copy ();
+
   value_bit *var_copy = var->copy ();
   bit_expression *node_with_const_child = nullptr;
   bit_expression *tmp = nullptr;
   get_parent_with_const_child (var_copy, node_with_const_child, tmp);
 
-  if (const_bit->get_val () == 0)
-    return var->copy ();
-  else if (node_with_const_child != nullptr)
+  if (node_with_const_child != nullptr)
     {
       value_bit *left = node_with_const_child->get_left ();
       if (left != nullptr && is_a<bit *> (left))
@@ -1150,10 +1120,8 @@ state::do_mul (value *arg1, value *arg2, tree dest)
 
       value *temp = shifted;
       shifted = shift_left_by_const (shifted, 1);
-      free_val (temp);
       delete temp;
     }
-  free_val (shifted);
   delete shifted;
 }
 
@@ -1715,8 +1683,6 @@ state::add_binary_cond (tree arg1, tree arg2, binary_cond_func cond_func)
     }
 
   (this->*cond_func) (arg1_val, arg2_val);
-  free_val (&arg1_const_val);
-  free_val (&arg2_const_val);
   print_conditions ();
   return true;
 }
@@ -1817,9 +1783,8 @@ value::value (unsigned size, bool is_unsigned) : is_unsigned (is_unsigned)
 }
 
 
-value::value (const value &other)
+value::value (const value &other) : is_unsigned (other.is_unsigned)
 {
-  this->is_unsigned = other.is_unsigned;
   number.create (other.length ());
   for (size_t i = 0; i < other.length (); ++i)
     {
@@ -2111,4 +2076,27 @@ value_bit **
 value::push (value_bit *elem)
 {
   return number.quick_push (elem);
+}
+
+
+value::~value ()
+{
+  free_bits ();
+  number.release ();
+}
+
+
+/* Removes given sequence of bits.  */
+
+void
+value::free_bits ()
+{
+  if (!number.exists ())
+    return;
+
+  for (size_t i = 0; i < number.length (); i++)
+    {
+      delete number[i];
+      number[i] = nullptr;
+    }
 }
\ No newline at end of file

diff --git a/gcc/sym-exec/state.h b/gcc/sym-exec/state.h
index e83b47806bea391ef0d25870709f36df9da85882..a7d289b91b76be792982253f195bdd736b193292 100644 (file)
--- a/gcc/sym-exec/state.h
+++ b/gcc/sym-exec/state.h
@@ -11,8 +11,11 @@
 #include "expression-is-a-helper.h"
 
 struct value {
+ private:
   vec<value_bit *> number;
-  bool is_unsigned;
+
+ public:
+  const bool is_unsigned;
 
   value (unsigned size, bool is_unsigned);
   value (const value &other);
@@ -24,6 +27,10 @@ struct value {
   value_bit *&operator[] (unsigned i);
   value &operator= (const value &other);
   value_bit *operator[] (unsigned i) const;
+  ~value ();
+
+  /* Removes given sequence of bits.  */
+  void free_bits ();
 };
 
 /* Stores states of variables' values on bit-level.  */
@@ -46,15 +53,9 @@ class state {
   /* The result of last added condition.  */
   condition_status last_cond_status = condition_status::CS_NO_COND;
 
-  /* Removes given value.  */
-  static void free_val (value *val);
-
   /* Creates value for given constant tree.  */
   static value create_val_for_const (tree var, size_t size);
 
-  /* Removes given sequence of bits.  */
-  static void free_bits (vec<value_bit *> *bits);
-
   /* Checks if sizes of arguments and destination are compatible.  */
   bool check_args_compatibility (tree arg1, tree arg2, tree dest);
 
@@ -368,26 +369,30 @@ state::operate (value *arg1, value *arg2, value_bit **bit_arg, tree dest,
     return;
 
   value *biggest = arg1;
+  value_bit *sign_bit = (*arg2)[i - 1];
   if (arg2->length () > arg1->length ())
-    biggest = arg2;
+    {
+      biggest = arg2;
+      sign_bit = (*arg1)[i - 1];
+    }
 
   min_iter = min (biggest->length (), dest_var->length (), dest_var->length ());
-  value_bit *zero_bit = new bit (0);
   for (; i < min_iter; i++)
     {
       value_bit *temp = (*var_states.get (dest))[i];
       (*var_states.get (dest))[i] = operate_bits (bit_op, (*biggest)[i],
-                                                 zero_bit, bit_arg);
+                                                 sign_bit, bit_arg);
       delete temp;
     }
 
   if (i >= dest_var->length ())
     return;
 
+  sign_bit = (*biggest)[i - 1];
   for (; i < dest_var->length (); i++)
     {
       value_bit *temp = (*var_states.get (dest))[i];
-      (*var_states.get (dest))[i] = operate_bits (bit_op, zero_bit, zero_bit,
+      (*var_states.get (dest))[i] = operate_bits (bit_op, sign_bit, sign_bit,
                                                  bit_arg);
       delete temp;
     }

diff --git a/gcc/testsuite/gcc.dg/crc-1.c b/gcc/testsuite/gcc.dg/crc-1.c
index cfa78e049b1140a0a27c238726ba00862891232b..8f306c30fdd084fcf7d4dde4a0b5c673d460b828 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-1.c
+++ b/gcc/testsuite/gcc.dg/crc-1.c
@@ -54,3 +54,5 @@ uint16_t gen_crc16(const uint8_t *data, uint16_t size) {
 /* { dg-final { scan-tree-dump "Bit forward" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+(\(\[a-zA-Z\]\))?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
+/* { dg-final { scan-tree-dump-times "Return value is \\\{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\\\}" 3 "crc" } } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1\\\}" "crc" } } */

diff --git a/gcc/testsuite/gcc.dg/crc-10.c b/gcc/testsuite/gcc.dg/crc-10.c
index 7cf77b856d6b442020430f70dc17ccc936158823..7a20c1f4b06ed989a42c40b1c3856009a677b313 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-10.c
+++ b/gcc/testsuite/gcc.dg/crc-10.c
@@ -23,3 +23,6 @@ u8 crc8(u16 data) {
 /* { dg-final { scan-tree-dump "Bit forward" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\] \\\^ 1\\\)\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\]\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0\\\}" "crc" } } */

diff --git a/gcc/testsuite/gcc.dg/crc-2.c b/gcc/testsuite/gcc.dg/crc-2.c
index 55d03bdd3eccc5096e67632014296bb90134a0f3..14e2b658852d881f92b3fe229462bb2bdb2eca33 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-2.c
+++ b/gcc/testsuite/gcc.dg/crc-2.c
@@ -28,3 +28,6 @@ unsigned int crc16(unsigned int crcValue, unsigned char newByte) {
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
 /* { dg-final { scan-tree-dump "crc16 function calculates CRC!" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[30\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[29\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[28\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[27\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[26\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[25\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[24\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[23\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[22\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[21\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[20\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[19\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[18\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[17\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[16\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\] \\\^ 1\\\), 0\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[30\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[29\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[28\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[27\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[26\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[25\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[24\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[23\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[22\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[21\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[20\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[19\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[18\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[17\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[16\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 0\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0\\\}" "crc" } } */

diff --git a/gcc/testsuite/gcc.dg/crc-23.c b/gcc/testsuite/gcc.dg/crc-23.c
index afc12827b732725ade270cd62e03835c65bd4b63..1d1fd2134a74a0da29ed2ed619857f5f860a3b6a 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-23.c
+++ b/gcc/testsuite/gcc.dg/crc-23.c
@@ -21,3 +21,6 @@ uint16_t crc16(uint16_t crc, uint8_t a, uint16_t polynom) {
 /* { dg-final { scan-tree-dump "Bit reversed" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\]\\\)\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\]\\\)\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\]\\\)\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\]\\\)\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\] \\\^ \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\]\\\)\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\]\\\)\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\] \\\^ \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\]\\\)\\\)\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{0, \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\]\\\)\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\]\\\}" "crc" } } */

diff --git a/gcc/testsuite/gcc.dg/crc-25.c b/gcc/testsuite/gcc.dg/crc-25.c
index 96add9e70fd6ca4c12b526b36634d8b3acabe7f3..f48714b0dc077fdbe5fe0d322ebbc20c7641e66a 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-25.c
+++ b/gcc/testsuite/gcc.dg/crc-25.c
@@ -26,4 +26,8 @@ crcSlow(uint8_t message) {
 /* { dg-final { scan-tree-dump "Loop iteration number is 7" "crc"} } */
 /* { dg-final { scan-tree-dump "Bit forward" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
-/* { dg-final { scan-tree-dump "crcSlow function calculates CRC." "crc"} } */
\ No newline at end of file
+/* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \(-\)?\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
+/* { dg-final { scan-tree-dump "crcSlow function calculates CRC." "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\] \\\^ 1\\\), 0\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 0\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{1, 1, 0, 1, 0, 0, 1, 0\\\}" "crc"} } */
\ No newline at end of file

diff --git a/gcc/testsuite/gcc.dg/crc-3.c b/gcc/testsuite/gcc.dg/crc-3.c
index cf5267c464242627b00d2aba81d32d0c6cfbc4a1..087e0faeb226053c4afa25e5fd025546dab21683 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-3.c
+++ b/gcc/testsuite/gcc.dg/crc-3.c
@@ -32,3 +32,7 @@ unsigned short crc16(char *data_p, unsigned short length) {
 /* { dg-final { scan-tree-dump "Bit reversed" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\(0, \)*0\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0\\\}" "crc" } } */

diff --git a/gcc/testsuite/gcc.dg/crc-4.c b/gcc/testsuite/gcc.dg/crc-4.c
index 7cd3d62ea154bcf3419471eb7756df1f2cf01cbc..5f6b354ddd86e6f7e1e77a31efd16941f48b1e6a 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-4.c
+++ b/gcc/testsuite/gcc.dg/crc-4.c
@@ -21,4 +21,7 @@ uint16_t crc16_update(uint16_t crc, uint8_t a) {
 /* { dg-final { scan-tree-dump "Bit reversed" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
-/* { dg-final { scan-tree-dump "crc16_update function calculates CRC!" "crc"} } */
\ No newline at end of file
+/* { dg-final { scan-tree-dump "crc16_update function calculates CRC!" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{1, \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\]\\\), \\\(\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\]\\\) \\\^ 1\\\)\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{0, \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\]\\\)\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1\\\}" "crc" } } */

diff --git a/gcc/testsuite/gcc.dg/crc-5.c b/gcc/testsuite/gcc.dg/crc-5.c
index c9009051b3e20c374ee8645622efa7271513978f..438521627e2523c65c5f77313da21c2c18f19773 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-5.c
+++ b/gcc/testsuite/gcc.dg/crc-5.c
@@ -28,4 +28,8 @@ ee_u16 crcu8(ee_u8 data, ee_u16 crc) {
 /* { dg-final { scan-tree-dump "Bit reversed" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
-/* { dg-final { scan-tree-dump "crcu8 function calculates CRC!" "crc"} } */
\ No newline at end of file
+/* { dg-final { scan-tree-dump "crcu8 function calculates CRC!" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{1, \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ 1\\\)\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{0, \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[15\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\]\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1\\\}" "crc" } } */
+

diff --git a/gcc/testsuite/gcc.dg/crc-6.c b/gcc/testsuite/gcc.dg/crc-6.c
index cfb40b47b271e285b27d680876c6000feaefda0e..7e64f7ae7b462bc01ec36d6c5f246a5a29c5b000 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-6.c
+++ b/gcc/testsuite/gcc.dg/crc-6.c
@@ -32,3 +32,7 @@ crcSlow(uint8_t const message[], int nBytes) {
 /* { dg-final { scan-tree-dump "Bit forward" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\] \\\^ 1\\\), 0\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\( \\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 0\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\(0, \)*0\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{1, 1, 0, 1, 0, 0, 1, 0\\\}" "crc" } } */

diff --git a/gcc/testsuite/gcc.dg/crc-7.c b/gcc/testsuite/gcc.dg/crc-7.c
index d042a0b7b876756695cca385b98ee1a1004a327e..4c5814584aaadda790c6da2ba5ffef9b3ccf3396 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-7.c
+++ b/gcc/testsuite/gcc.dg/crc-7.c
@@ -21,4 +21,7 @@ uint16_t crc_xmodem_update(uint16_t crc, uint8_t data) {
 /* { dg-final { scan-tree-dump "Bit forward" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
-/* { dg-final { scan-tree-dump "crc_xmodem_update function calculates CRC!" "crc"} } */
\ No newline at end of file
+/* { dg-final { scan-tree-dump "crc_xmodem_update function calculates CRC!" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\]\\\), \\\(\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\]\\\) \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\]\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 1\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\]\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 0\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1\\\}" "crc"} } */

diff --git a/gcc/testsuite/gcc.dg/crc-8.c b/gcc/testsuite/gcc.dg/crc-8.c
index ec990e1f78df3506c28b024b013eba50fc6c7115..7bdb8b9a7d675b27a5dda4c6ea7b2f8a0aba5458 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-8.c
+++ b/gcc/testsuite/gcc.dg/crc-8.c
@@ -22,3 +22,6 @@ uint8_t _crc_ibutton_update(uint8_t crc, uint8_t data) {
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
 /* { dg-final { scan-tree-dump "_crc_ibutton_update function calculates CRC!" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{1, \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\]\\\), \\\(\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\]\\\) \\\^ 1\\\), \\\(\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\]\\\) \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\]\\\)\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{0, \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\]\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\]\\\)\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{1, 0, 0, 0, 1, 1, 0, 0\\\}" "crc" } } */

diff --git a/gcc/testsuite/gcc.dg/crc-9.c b/gcc/testsuite/gcc.dg/crc-9.c
index d48e9ce532cf2bd990e7f0cde196610ab9447c29..bac21505b664f318921c2ac7651839cc9e740bf7 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-9.c
+++ b/gcc/testsuite/gcc.dg/crc-9.c
@@ -26,3 +26,7 @@ uint8_t gencrc(uint8_t *data, size_t len) {
 /* { dg-final { scan-tree-dump "Bit forward" "crc"} } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
 /* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ 0\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ 0\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\] \\\^ 1\\\), 1\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\] \\\^ 1\\\), 0\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\(1, \)*1\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{0, 0, 1, 1, 0, 0, 0, 1\\\}" "crc" } } */

diff --git a/gcc/testsuite/gcc.dg/crc-callerid.c b/gcc/testsuite/gcc.dg/crc-callerid.c
index 2d2dc746a83e81c58b2b10226b989b5453d8b6de..4137d79b288f52dbfd2353f2687ca3d4712e0bb2 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-callerid.c
+++ b/gcc/testsuite/gcc.dg/crc-callerid.c
@@ -26,4 +26,10 @@ unsigned short calc_crc(unsigned short crc, unsigned char data)
 /* { dg-final { scan-tree-dump "Return size is 16" "crc"} } */
 /* { dg-final { scan-tree-dump "Loop iteration number is 7" "crc"} } */
 /* { dg-final { scan-tree-dump "Bit forward" "crc"} } */
-/* { dg-final { scan-tree-dump "calc_crc function calculates CRC." "crc"} } */
\ No newline at end of file
+/* { dg-final { scan-tree-dump "calc_crc function calculates CRC." "crc"} } */
+/* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
+/* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 1\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 0\\\}" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[14\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[13\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[12\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[11\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[10\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[9\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[8\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[7\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 1\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump-times "Polynomial's value is \\\{0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1\\\}" 1 "crc"} } */
\ No newline at end of file

diff --git a/gcc/testsuite/gcc.dg/crc-cc1541.c b/gcc/testsuite/gcc.dg/crc-cc1541.c
index 8a4ad4b32c63789e24bf867c82b6b4307e6152b5..a1ba5f8b319b704bec0b1778dabd48ed01f3b7bd 100644 (file)
--- a/gcc/testsuite/gcc.dg/crc-cc1541.c
+++ b/gcc/testsuite/gcc.dg/crc-cc1541.c
@@ -13,4 +13,9 @@ crc8(unsigned char value)
 /* { dg-final { scan-tree-dump "Return size is 8" "crc"} } */
 /* { dg-final { scan-tree-dump "Loop iteration number is 7" "crc"} } */
 /* { dg-final { scan-tree-dump "Bit forward" "crc"} } */
-/* { dg-final { scan-tree-dump "crc8 function calculates CRC." "crc"} } */
\ No newline at end of file
+/* { dg-final { scan-tree-dump "crc8 function calculates CRC." "crc"} } */
+/* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \\\^ \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?;" "crc" } } */
+/* { dg-final { scan-tree-dump "Executing \[a-zA-Z_\]\[a-zA-Z0-9_\\\.\]* = \[a-zA-Z_\]\[a-zA-Z0-9_\]* \(<<|>>\) \[0-9]+;" "crc" } } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\] \\\^ 1\\\), \\\(\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\] \\\^ 1\\\), \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 1\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Return value is \\\{\[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[6\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[5\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[4\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[3\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[2\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[1\\\], \[a-zA-Z0-9_\]+\(\\\(\[a-zA-Z\]\\\)\)?\\\[0\\\], 0\\\}" "crc"} } */
+/* { dg-final { scan-tree-dump "Polynomial's value is \\\{0, 0, 1, 1, 0, 0, 0, 1\\\}" "crc"} } */
\ No newline at end of file