This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
A patch for genautomata.c
- From: Vladimir Makarov <vmakarov at cygnus dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Tue, 21 May 2002 19:17:20 -0400
- Subject: A patch for genautomata.c
Hello,
I've just committed the patch which fixes minor problems in
genautomata.c. The patch has been tested, on i386, alpha, sparc and
sh.
Vlad
2002-05-21 Vladimir Makarov <vmakarov@redhat.com>
* genautomata.c (reserv_sets_hash_value): Define hash_value as
set_el_t. Transform the hash value into unsigned.
(output_cycle_reservs): Fix bug with output of repeated `nothing'.
(transform_3): Add code to process `(A,B)+(D,E)'.
Index: genautomata.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/genautomata.c,v
retrieving revision 1.11
diff -c -p -r1.11 genautomata.c
*** genautomata.c 14 May 2002 16:16:18 -0000 1.11
--- genautomata.c 21 May 2002 22:37:06 -0000
*************** static unsigned
*** 3391,3411 ****
reserv_sets_hash_value (reservs)
reserv_sets_t reservs;
{
! unsigned int hash_value;
! int reservs_num;
set_el_t *reserv_ptr;
hash_value = 0;
reservs_num = els_in_reservs;
reserv_ptr = reservs;
while (reservs_num != 0)
{
reservs_num--;
! hash_value = ((hash_value >> (sizeof (unsigned) - 1) * CHAR_BIT)
! | (hash_value << CHAR_BIT)) + *reserv_ptr;
reserv_ptr++;
}
! return hash_value;
}
/* Comparison of given reservation sets. */
--- 3391,3424 ----
reserv_sets_hash_value (reservs)
reserv_sets_t reservs;
{
! set_el_t hash_value;
! unsigned result;
! int reservs_num, i;
set_el_t *reserv_ptr;
hash_value = 0;
reservs_num = els_in_reservs;
reserv_ptr = reservs;
+ i = 0;
while (reservs_num != 0)
{
reservs_num--;
! hash_value += ((*reserv_ptr >> i)
! | (*reserv_ptr << (sizeof (set_el_t) * CHAR_BIT - i)));
! i++;
! if (i == sizeof (set_el_t) * CHAR_BIT)
! i = 0;
reserv_ptr++;
}
! if (sizeof (set_el_t) < sizeof (unsigned))
! return hash_value;
! result = 0;
! for (i = sizeof (set_el_t); i > 0; i -= sizeof (unsigned))
! {
! result += (unsigned) hash_value;
! hash_value >>= sizeof (unsigned) * CHAR_BIT;
! }
! return result;
}
/* Comparison of given reservation sets. */
*************** output_cycle_reservs (f, reservs, start_
*** 3638,3649 ****
fprintf (f, NOTHING_NAME);
if (repetition_num <= 0)
abort ();
! if (reserved_units_num != 0 && repetition_num != 1)
! {
! if (reserved_units_num > 1)
! fprintf (f, ")");
! fprintf (f, "*%d", repetition_num);
! }
}
/* The function outputs string representation of units reservation in
--- 3651,3660 ----
fprintf (f, NOTHING_NAME);
if (repetition_num <= 0)
abort ();
! if (reserved_units_num > 1)
! fprintf (f, ")");
! if (repetition_num != 1)
! fprintf (f, "*%d", repetition_num);
}
/* The function outputs string representation of units reservation in
*************** transform_2 (regexp)
*** 4638,4644 ****
/* The function makes transformations
...,A|B|...,C,... -> (...,A,C,...)|(...,B,C,...)|...
...+(A|B|...)+C+... -> (...+A+C+...)|(...+B+C+...)|...
! ...+(A,B,...)+C+... -> (...+A+C+...),B,... */
static regexp_t
transform_3 (regexp)
regexp_t regexp;
--- 4649,4656 ----
/* The function makes transformations
...,A|B|...,C,... -> (...,A,C,...)|(...,B,C,...)|...
...+(A|B|...)+C+... -> (...+A+C+...)|(...+B+C+...)|...
! ...+(A,B,...)+C+... -> (...+A+C+...),B,...
! ...+(A,B,...)+(C,D,...) -> (A+C),(B+D),... */
static regexp_t
transform_3 (regexp)
regexp_t regexp;
*************** transform_3 (regexp)
*** 4695,4703 ****
else if (regexp->mode == rm_allof)
{
regexp_t oneof, seq;
! int oneof_index, seq_index;
regexp_t result;
! regexp_t allof;
int i, j;
for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
--- 4707,4715 ----
else if (regexp->mode == rm_allof)
{
regexp_t oneof, seq;
! int oneof_index, max_seq_length, allof_length;
regexp_t result;
! regexp_t allof, allof_op;
int i, j;
for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
*************** transform_3 (regexp)
*** 4740,4781 ****
regexp_transformed_p = 1;
regexp = result;
}
for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
if (regexp->regexp.allof.regexps [i]->mode == rm_sequence)
{
- seq_index = i;
seq = regexp->regexp.allof.regexps [i];
break;
}
! if (i < regexp->regexp.allof.regexps_num)
{
! if (seq->regexp.sequence.regexps_num <= 1
! || regexp->regexp.allof.regexps_num <= 1)
abort ();
result = create_node (sizeof (struct regexp)
! + sizeof (regexp_t)
! * (seq->regexp.sequence.regexps_num - 1));
result->mode = rm_sequence;
result->pos = regexp->pos;
! result->regexp.sequence.regexps_num
! = seq->regexp.sequence.regexps_num;
! allof = create_node (sizeof (struct regexp)
! + sizeof (regexp_t)
! * (regexp->regexp.allof.regexps_num - 1));
! allof->mode = rm_allof;
! allof->pos = regexp->pos;
! allof->regexp.allof.regexps_num = regexp->regexp.allof.regexps_num;
! result->regexp.sequence.regexps [0] = allof;
! for (j = 0; j < allof->regexp.allof.regexps_num; j++)
! if (j != seq_index)
! allof->regexp.allof.regexps [j]
! = copy_insn_regexp (regexp->regexp.allof.regexps [j]);
! else
! allof->regexp.allof.regexps [j]
! = copy_insn_regexp (seq->regexp.sequence.regexps [0]);
! for (i = 1; i < result->regexp.sequence.regexps_num; i++)
! result->regexp.sequence.regexps [i]
! = copy_insn_regexp (seq->regexp.sequence.regexps [i]);
regexp_transformed_p = 1;
regexp = result;
}
--- 4752,4830 ----
regexp_transformed_p = 1;
regexp = result;
}
+ max_seq_length = 0;
for (i = 0; i < regexp->regexp.allof.regexps_num; i++)
if (regexp->regexp.allof.regexps [i]->mode == rm_sequence)
{
seq = regexp->regexp.allof.regexps [i];
+ if (max_seq_length < seq->regexp.sequence.regexps_num)
+ max_seq_length = seq->regexp.sequence.regexps_num;
+ }
+ else if (regexp->regexp.allof.regexps [i]->mode != rm_unit)
+ {
+ max_seq_length = 0;
break;
}
! if (max_seq_length != 0)
{
! if (max_seq_length == 1 || regexp->regexp.allof.regexps_num <= 1)
abort ();
result = create_node (sizeof (struct regexp)
! + sizeof (regexp_t) * (max_seq_length - 1));
result->mode = rm_sequence;
result->pos = regexp->pos;
! result->regexp.sequence.regexps_num = max_seq_length;
! for (i = 0; i < max_seq_length; i++)
! {
! allof_length = 0;
! for (j = 0; j < regexp->regexp.allof.regexps_num; j++)
! if (regexp->regexp.allof.regexps [j]->mode == rm_sequence
! && (i < (regexp->regexp.allof.regexps [j]
! ->regexp.sequence.regexps_num)))
! {
! allof_op = (regexp->regexp.allof.regexps [j]
! ->regexp.sequence.regexps [i]);
! allof_length++;
! }
! else if (i == 0
! && regexp->regexp.allof.regexps [j]->mode == rm_unit)
! {
! allof_op = regexp->regexp.allof.regexps [j];
! allof_length++;
! }
! if (allof_length == 1)
! result->regexp.sequence.regexps [i] = allof_op;
! else
! {
! allof = create_node (sizeof (struct regexp)
! + sizeof (regexp_t)
! * (allof_length - 1));
! allof->mode = rm_allof;
! allof->pos = regexp->pos;
! allof->regexp.allof.regexps_num = allof_length;
! result->regexp.sequence.regexps [i] = allof;
! allof_length = 0;
! for (j = 0; j < regexp->regexp.allof.regexps_num; j++)
! if (regexp->regexp.allof.regexps [j]->mode == rm_sequence
! && (i < (regexp->regexp.allof.regexps [j]
! ->regexp.sequence.regexps_num)))
! {
! allof_op = (regexp->regexp.allof.regexps [j]
! ->regexp.sequence.regexps [i]);
! allof->regexp.allof.regexps [allof_length] = allof_op;
!
! allof_length++;
! }
! else if (i == 0
! && (regexp->regexp.allof.regexps [j]->mode
! == rm_unit))
! {
! allof_op = regexp->regexp.allof.regexps [j];
! allof->regexp.allof.regexps [allof_length] = allof_op;
! allof_length++;
! }
! }
! }
regexp_transformed_p = 1;
regexp = result;
}