X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgenautomata.c;h=afc97afd4a2d8bc1ff9a3de42111eed3e2457a62;hb=e440a3286bc89368b8d3a8fd6accd47191790bf2;hp=f3321410da5a6afd5b23678f4e7319ae5100fbc6;hpb=48e1416a24d50cacbb2a5e06a9ee61dd8cbee313;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/genautomata.c b/gcc/genautomata.c index f3321410da5..afc97afd4a2 100644 --- a/gcc/genautomata.c +++ b/gcc/genautomata.c @@ -1603,7 +1603,7 @@ gen_regexp_repeat (const char *str) return regexp; } else - return gen_regexp_el (str); + return gen_regexp_el (repeat_vect[0]); } /* Parse reservation STR which possibly contains separator '+'. */ @@ -1629,7 +1629,7 @@ gen_regexp_allof (const char *str) return allof; } else - return gen_regexp_repeat (str); + return gen_regexp_repeat (allof_vect[0]); } /* Parse reservation STR which possibly contains separator '|'. */ @@ -1655,7 +1655,7 @@ gen_regexp_oneof (const char *str) return oneof; } else - return gen_regexp_allof (str); + return gen_regexp_allof (oneof_vect[0]); } /* Parse reservation STR which possibly contains separator ','. */ @@ -1680,7 +1680,7 @@ gen_regexp_sequence (const char *str) return sequence; } else - return gen_regexp_oneof (str); + return gen_regexp_oneof (sequence_vect[0]); } /* Parse construction reservation STR. */ @@ -1688,7 +1688,7 @@ static regexp_t gen_regexp (const char *str) { reserv_str = str; - return gen_regexp_sequence (str);; + return gen_regexp_sequence (str); } /* Process a DEFINE_RESERVATION. @@ -3252,9 +3252,7 @@ uniq_sort_alt_states (alt_state_t alt_states_list) curr_alt_state = curr_alt_state->next_alt_state) VEC_safe_push (alt_state_t, heap, alt_states, curr_alt_state); - qsort (VEC_address (alt_state_t, alt_states), - VEC_length (alt_state_t, alt_states), - sizeof (alt_state_t), alt_state_cmp); + VEC_qsort (alt_state_t, alt_states, alt_state_cmp); prev_unique_state_ind = 0; for (i = 1; i < VEC_length (alt_state_t, alt_states); i++) @@ -3314,15 +3312,18 @@ finish_alt_states (void) /* Set bit number bitno in the bit string. The macro is not side effect proof. */ #define SET_BIT(bitstring, bitno) \ - (((char *) (bitstring)) [(bitno) / CHAR_BIT] |= 1 << (bitno) % CHAR_BIT) + ((bitstring)[(bitno) / (sizeof (*(bitstring)) * CHAR_BIT)] |= \ + (HOST_WIDE_INT)1 << (bitno) % (sizeof (*(bitstring)) * CHAR_BIT)) #define CLEAR_BIT(bitstring, bitno) \ - (((char *) (bitstring)) [(bitno) / CHAR_BIT] &= ~(1 << (bitno) % CHAR_BIT)) + ((bitstring)[(bitno) / (sizeof (*(bitstring)) * CHAR_BIT)] &= \ + ~((HOST_WIDE_INT)1 << (bitno) % (sizeof (*(bitstring)) * CHAR_BIT))) /* Test if bit number bitno in the bitstring is set. The macro is not side effect proof. */ -#define TEST_BIT(bitstring, bitno) \ - (((char *) (bitstring)) [(bitno) / CHAR_BIT] >> (bitno) % CHAR_BIT & 1) +#define TEST_BIT(bitstring, bitno) \ + ((bitstring)[(bitno) / (sizeof (*(bitstring)) * CHAR_BIT)] >> \ + (bitno) % (sizeof (*(bitstring)) * CHAR_BIT) & 1) @@ -4174,20 +4175,18 @@ initiate_excl_sets (void) static reserv_sets_t get_excl_set (reserv_sets_t in_set) { - int excl_char_num; - int chars_num; - int i; + int el; + unsigned int i; int start_unit_num; int unit_num; - chars_num = els_in_cycle_reserv * sizeof (set_el_t); - memset (excl_set, 0, chars_num); - for (excl_char_num = 0; excl_char_num < chars_num; excl_char_num++) - if (((unsigned char *) in_set) [excl_char_num]) - for (i = CHAR_BIT - 1; i >= 0; i--) - if ((((unsigned char *) in_set) [excl_char_num] >> i) & 1) + memset (excl_set, 0, els_in_cycle_reserv * sizeof (set_el_t)); + for (el = 0; el < els_in_cycle_reserv; el++) + if (in_set[el]) + for (i = 0; i < CHAR_BIT * sizeof (set_el_t); i++) + if ((in_set[el] >> i) & 1) { - start_unit_num = excl_char_num * CHAR_BIT + i; + start_unit_num = el * CHAR_BIT * sizeof (set_el_t) + i; if (start_unit_num >= description->units_num) return excl_set; for (unit_num = 0; unit_num < els_in_cycle_reserv; unit_num++) @@ -4286,21 +4285,19 @@ check_presence_pattern_sets (reserv_sets_t checked_set, reserv_sets_t original_set, int final_p) { - int char_num; - int chars_num; - int i; + int el; + unsigned int i; int start_unit_num; int unit_num; int presence_p; pattern_reserv_t pat_reserv; - chars_num = els_in_cycle_reserv * sizeof (set_el_t); - for (char_num = 0; char_num < chars_num; char_num++) - if (((unsigned char *) original_set) [char_num]) - for (i = CHAR_BIT - 1; i >= 0; i--) - if ((((unsigned char *) original_set) [char_num] >> i) & 1) + for (el = 0; el < els_in_cycle_reserv; el++) + if (original_set[el]) + for (i = 0; i < CHAR_BIT * sizeof (set_el_t); i++) + if ((original_set[el] >> i) & 1) { - start_unit_num = char_num * CHAR_BIT + i; + start_unit_num = el * CHAR_BIT * sizeof (set_el_t) + i; if (start_unit_num >= description->units_num) break; if ((final_p @@ -4335,20 +4332,18 @@ check_absence_pattern_sets (reserv_sets_t checked_set, reserv_sets_t original_set, int final_p) { - int char_num; - int chars_num; - int i; + int el; + unsigned int i; int start_unit_num; int unit_num; pattern_reserv_t pat_reserv; - chars_num = els_in_cycle_reserv * sizeof (set_el_t); - for (char_num = 0; char_num < chars_num; char_num++) - if (((unsigned char *) original_set) [char_num]) - for (i = CHAR_BIT - 1; i >= 0; i--) - if ((((unsigned char *) original_set) [char_num] >> i) & 1) + for (el = 0; el < els_in_cycle_reserv; el++) + if (original_set[el]) + for (i = 0; i < CHAR_BIT * sizeof (set_el_t); i++) + if ((original_set[el] >> i) & 1) { - start_unit_num = char_num * CHAR_BIT + i; + start_unit_num = el * CHAR_BIT * sizeof (set_el_t) + i; if (start_unit_num >= description->units_num) break; for (pat_reserv = (final_p @@ -6007,9 +6002,7 @@ evaluate_equiv_classes (automaton_t automaton, all_achieved_states = VEC_alloc (state_t, heap, 1500); pass_states (automaton, add_achieved_state); pass_states (automaton, cache_presence); - qsort (VEC_address (state_t, all_achieved_states), - VEC_length (state_t, all_achieved_states), - sizeof (state_t), compare_states_for_equiv); + VEC_qsort (state_t, all_achieved_states, compare_states_for_equiv); odd_iteration_flag = 0; new_equiv_class_num = init_equiv_class (all_achieved_states, @@ -7459,9 +7452,7 @@ output_trans_table (automaton_t automaton) from the state (state with the maximum num is the first). */ output_states_vect = 0; pass_states (automaton, add_states_vect_el); - qsort (VEC_address (state_t, output_states_vect), - VEC_length (state_t, output_states_vect), - sizeof (state_t), compare_transition_els_num); + VEC_qsort (state_t, output_states_vect, compare_transition_els_num); for (i = 0; i < VEC_length (state_t, output_states_vect); i++) { @@ -7488,72 +7479,6 @@ output_trans_table (automaton_t automaton) VEC_free (vect_el_t, heap, transition_vect); } -/* The current number of passing states to find minimal issue delay - value for an ainsn and state. */ -static int curr_state_pass_num; - -/* This recursive function passes states to find minimal issue delay - value for AINSN. The state being visited is STATE. The function - returns minimal issue delay value for AINSN in STATE or -1 if we - enter into a loop. */ -static int -min_issue_delay_pass_states (state_t state, ainsn_t ainsn) -{ - arc_t arc; - int min_insn_issue_delay, insn_issue_delay; - - if (state->state_pass_num == curr_state_pass_num - || state->min_insn_issue_delay != -1) - /* We've entered into a loop or already have the correct value for - given state and ainsn. */ - return state->min_insn_issue_delay; - state->state_pass_num = curr_state_pass_num; - min_insn_issue_delay = -1; - for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc)) - if (arc->insn == ainsn) - { - min_insn_issue_delay = 0; - break; - } - else - { - insn_issue_delay = min_issue_delay_pass_states (arc->to_state, ainsn); - if (insn_issue_delay != -1) - { - if (arc->insn->insn_reserv_decl - == DECL_INSN_RESERV (advance_cycle_insn_decl)) - insn_issue_delay++; - if (min_insn_issue_delay == -1 - || min_insn_issue_delay > insn_issue_delay) - { - min_insn_issue_delay = insn_issue_delay; - if (insn_issue_delay == 0) - break; - } - } - } - return min_insn_issue_delay; -} - -/* The function searches minimal issue delay value for AINSN in STATE. - The function can return negative value if we can not issue AINSN. We - will report about it later. */ -static int -min_issue_delay (state_t state, ainsn_t ainsn) -{ - curr_state_pass_num++; - state->min_insn_issue_delay = min_issue_delay_pass_states (state, ainsn); - return state->min_insn_issue_delay; -} - -/* The function initiates code for finding minimal issue delay values. - It should be called only once. */ -static void -initiate_min_issue_delay_pass_states (void) -{ - curr_state_pass_num = 0; -} - /* Form and output vectors representing minimal issue delay table of AUTOMATON. The table is state x ainsn -> minimal issue delay of the ainsn. */ @@ -7562,11 +7487,11 @@ output_min_issue_delay_table (automaton_t automaton) { vla_hwint_t min_issue_delay_vect; vla_hwint_t compressed_min_issue_delay_vect; - vect_el_t min_delay; ainsn_t ainsn; - size_t i, min_issue_delay_len; - size_t compressed_min_issue_delay_len; + size_t i; + size_t min_issue_delay_len, compressed_min_issue_delay_len; size_t cfactor; + int changed; /* Create vect of pointers to states ordered by num of transitions from the state (state with the maximum num is the first). */ @@ -7577,27 +7502,86 @@ output_min_issue_delay_table (automaton_t automaton) * automaton->insn_equiv_classes_num); min_issue_delay_vect = VEC_alloc (vect_el_t, heap, min_issue_delay_len); for (i = 0; i < min_issue_delay_len; i++) - VEC_quick_push (vect_el_t, min_issue_delay_vect, 0); + VEC_quick_push (vect_el_t, min_issue_delay_vect, -1); automaton->max_min_delay = 0; - for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn) + + do + { + size_t state_no; + + changed = 0; + + for (state_no = 0; state_no < VEC_length (state_t, output_states_vect); + state_no++) + { + state_t s = VEC_index (state_t, output_states_vect, state_no); + arc_t arc; + + for (arc = first_out_arc (s); arc; arc = next_out_arc (arc)) + { + int k; + + size_t asn = s->order_state_num + * automaton->insn_equiv_classes_num + + arc->insn->insn_equiv_class_num; + + if (VEC_index (vect_el_t, min_issue_delay_vect, asn)) + { + VEC_replace (vect_el_t, min_issue_delay_vect, asn, 0); + changed = 1; + } + + for (k = 0; k < automaton->insn_equiv_classes_num; k++) + { + size_t n0, n1; + vect_el_t delay0, delay1; + + n0 = s->order_state_num + * automaton->insn_equiv_classes_num + + k; + n1 = arc->to_state->order_state_num + * automaton->insn_equiv_classes_num + + k; + delay0 = VEC_index (vect_el_t, min_issue_delay_vect, n0); + delay1 = VEC_index (vect_el_t, min_issue_delay_vect, n1); + if (delay1 != -1) + { + if (arc->insn->insn_reserv_decl + == DECL_INSN_RESERV (advance_cycle_insn_decl)) + delay1++; + if (delay1 < delay0 || delay0 == -1) + { + VEC_replace (vect_el_t, min_issue_delay_vect, n0, delay1); + changed = 1; + } + } + } + } + } + } + while (changed); + + automaton->max_min_delay = 0; + + for (ainsn = automaton->ainsn_list; ainsn; ainsn = ainsn->next_ainsn) if (ainsn->first_ainsn_with_given_equivalence_num) { for (i = 0; i < VEC_length (state_t, output_states_vect); i++) - VEC_index (state_t, output_states_vect, i)->min_insn_issue_delay = -1; - for (i = 0; i < VEC_length (state_t, output_states_vect); i++) { state_t s = VEC_index (state_t, output_states_vect, i); - min_delay = min_issue_delay (s, ainsn); - if (automaton->max_min_delay < min_delay) - automaton->max_min_delay = min_delay; - VEC_replace (vect_el_t, min_issue_delay_vect, - s->order_state_num - * automaton->insn_equiv_classes_num - + ainsn->insn_equiv_class_num, - min_delay); + size_t np = s->order_state_num + * automaton->insn_equiv_classes_num + + ainsn->insn_equiv_class_num; + vect_el_t x = VEC_index (vect_el_t, min_issue_delay_vect, np); + + if (automaton->max_min_delay < x) + automaton->max_min_delay = x; + if (x == -1) + VEC_replace (vect_el_t, min_issue_delay_vect, np, 0); } } + fprintf (output_file, "/* Vector of min issue delay of insns. */\n"); fprintf (output_file, "static const "); output_range_type (output_file, 0, automaton->max_min_delay); @@ -7749,7 +7733,6 @@ output_tables (void) { automaton_t automaton; - initiate_min_issue_delay_pass_states (); for (automaton = description->first_automaton; automaton != NULL; automaton = automaton->next_automaton) @@ -7865,12 +7848,15 @@ output_automata_list_min_issue_delay_code (automata_list_el_t automata_list) { fprintf (output_file, ") / %d];\n", automaton->min_issue_delay_table_compression_factor); - fprintf (output_file, " %s = (%s >> (8 - (", + fprintf (output_file, " %s = (%s >> (8 - ((", TEMPORARY_VARIABLE_NAME, TEMPORARY_VARIABLE_NAME); output_translate_vect_name (output_file, automaton); + fprintf (output_file, " [%s] + ", INTERNAL_INSN_CODE_NAME); + fprintf (output_file, "%s->", CHIP_PARAMETER_NAME); + output_chip_member_name (output_file, automaton); + fprintf (output_file, " * %d)", automaton->insn_equiv_classes_num); fprintf - (output_file, " [%s] %% %d + 1) * %d)) & %d;\n", - INTERNAL_INSN_CODE_NAME, + (output_file, " %% %d + 1) * %d)) & %d;\n", automaton->min_issue_delay_table_compression_factor, 8 / automaton->min_issue_delay_table_compression_factor, (1 << (8 / automaton->min_issue_delay_table_compression_factor)) @@ -8952,9 +8938,7 @@ output_state (state_t state) fprintf (output_description_file, state->new_cycle_p ? " (new cycle)\n" : "\n"); add_state_reservs (state); - qsort (VEC_address (reserv_sets_t, state_reservs), - VEC_length (reserv_sets_t, state_reservs), - sizeof (reserv_sets_t), state_reservs_cmp); + VEC_qsort (reserv_sets_t, state_reservs, state_reservs_cmp); remove_state_duplicate_reservs (); for (i = 0; i < VEC_length (reserv_sets_t, state_reservs); i++) { @@ -9478,7 +9462,7 @@ main (int argc, char **argv) progname = "genautomata"; - if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE) + if (!init_rtx_reader_args (argc, argv)) return (FATAL_EXIT_CODE); initiate_automaton_gen (argc, argv); @@ -9565,16 +9549,27 @@ main (int argc, char **argv) "#include \"insn-config.h\"\n" "#include \"recog.h\"\n" "#include \"regs.h\"\n" - "#include \"real.h\"\n" "#include \"output.h\"\n" "#include \"insn-attr.h\"\n" - "#include \"toplev.h\"\n" + "#include \"diagnostic-core.h\"\n" "#include \"flags.h\"\n" - "#include \"function.h\"\n"); + "#include \"function.h\"\n" + "#include \"emit-rtl.h\"\n"); + /* FIXME: emit-rtl.h can go away once crtl is in rtl.h. */ write_automata (); } } + else + { + puts ("/* Generated automatically by the program `genautomata'\n" + " from the machine description file `md'. */\n\n" + "/* There is no automaton, but ISO C forbids empty\n" + " translation units, so include a header file with some\n" + " declarations, and its pre-requisite header file. */\n" + "#include \"config.h\"\n" + "#include \"system.h\"\n"); + } fflush (stdout); return (ferror (stdout) != 0 || have_error