GCC后端及汇编发布（26）

最新推荐文章于 2023-06-11 06:00:00 发布

wuhui_gdnt

最新推荐文章于 2023-06-11 06:00:00 发布

阅读量1.3k

点赞数

分类专栏： GCC后端及汇编发布文章标签： gcc 汇编 table list null struct

本文链接：https://blog.csdn.net/wuhui_gdnt/article/details/6537672

版权

GCC后端及汇编发布专栏收录该内容

49 篇文章 8 订阅

订阅专栏

9.5.8.2. 数据初始化

在构建自动机之前，首先要分配资源。

9416 static void

9417 generate (void) in genautomata.c

9418 {

9419 automata_num = split_argument ;

9420 if (description ->units_num < automata_num )

9421 automata_num = description ->units_num;

9422 initiate_states ();

9423 initiate_arcs ();

9424 initiate_automata_lists ();

9425 initiate_pass_states ();

9426 initiate_excl_sets ();

9427 initiate_presence_absence_pattern_sets ();

9428 automaton_generation_time = create_ticker ();

9429 create_automata ();

9430 ticker_off (&automaton_generation_time );

9431 }

split_argument 保存了自动机生成命令中“ split ”选项的值，它显示了所产生的自动机的数量。当然它不可能大于功能单元的数目。

正如我们之前已经看到的，正在构建的自动机的状态描述了指令执行的每个周期中，资源使用的情况。它由指令发布或周期推进所驱动，而周期推进，现在在引入了伪指令 advance_cycle_insn_decl 之后，也可以被视为指令发布。因此在这里，首先，需要把 CPU 功能单元记录入 units_array – 它是指令得以完成的资源，然后为状态位图分配资源。

4221 static void

4222 initiate_states (void) in genautomata.c

4223 {

4224 decl_t decl;

4225 int i;

4226

4227 VLA_PTR_CREATE (units_container , description ->units_num, "units_container");

4228 units_array

4229 = (description ->decls_num && description ->units_num

4230 ? VLA_PTR_BEGIN (units_container ) : NULL);

4231 for (i = 0; i < description ->decls_num; i++)

4232 {

4233 decl = description ->decls [i];

4234 if (decl->mode == dm_unit)

4235 units_array [DECL_UNIT (decl)->unit_num] = DECL_UNIT (decl);

4236 }

4237 max_cycles_num = description ->max_insn_reserv_cycles;

4238 els_in_cycle_reserv

4239 = ((description ->units_num + sizeof (set_el_t) * CHAR_BIT - 1)

4240 / (sizeof (set_el_t) * CHAR_BIT));

4241 els_in_reservs = els_in_cycle_reserv * max_cycles_num ;

4242 curr_unique_state_num = 0;

4243 initiate_alt_states ();

4244 VLA_PTR_CREATE (free_states , 1500, "free states");

4245 state_table = htab_create (1500, state_hash, state_eq_p, (htab_del) 0);

4246 temp_reserv = alloc_empty_reserv_sets ();

4247 }

first_free_alt_state 将指向由空闲 alt_state 组成的链表，对于某个状态，它将把替代链接起来。它首先在 initiate_alt_states 中被初始化为 null 。

3669 static void

3670 initiate_alt_states (void) in genautomata.c

3671 {

3672 first_free_alt_state = NULL;

3673 }

set_el_t 被 typedef 为 unsigned HOST_WIDE_INT ，而 reserv_sets_t 则 typedef 为其指针类型。显然 reserv_sets_t 的值用于代表功能单元的预订。 els_in_reservs 在 initiate_states 的 4241 行计算，相关的还有 max_cycles_num 及 els_in_cycle_reserv 。

3744 static reserv_sets_t

3745 alloc_empty_reserv_sets (void) in genautomata.c

3746 {

3747 reserv_sets_t result;

3748

3749 obstack_blank (&irp , els_in_reservs * sizeof (set_el_t));

3750 result = (reserv_sets_t) obstack_base (&irp );

3751 obstack_finish (&irp );

3752 memset (result, 0, els_in_reservs * sizeof (set_el_t));

3753 return result;

3754 }

first_free_arc 将指向空闲的 arc 链表，它将记录状态的迁移。

4368 static void

4369 initiate_arcs (void) in genautomata.c

4370 {

4371 first_free_arc = NULL;

4372 }

同样 first_free_automata_list_el 用于指向空闲的 automaton 的链表。所有的自动机对象将被保存在哈希表中，以保证其唯一性。

4474 static void

4475 initiate_automata_lists (void) in genautomata.c

4476 {

4477 first_free_automata_list_el = NULL;

4478 automata_list_table = htab_create (1500, automata_list_hash,

4479 automata_list_eq_p, (htab_del) 0);

4480 }

静态变量 curr_state_graph_pass_num 将用于记录状态传递图（ passing graph of states ）的当前数目。

5986 static void

5987 initiate_pass_states (void) in genautomata.c

5988 {

5989 curr_state_graph_pass_num = 0;

5990 }

而对于那些被 exclusion_set 所引用的指令，分配用于记录互斥及的位图资源。这里使用到了 obstack 机制的缓存，有关这部分的内容可以参考前端相关章节。总之， obstack 是 GCC 自己管理的内存块。

4544 static void

4545 initiate_excl_sets (void) in genautomata.c

4546 {

4547 decl_t decl;

4548 reserv_sets_t unit_excl_set;

4549 unit_set_el_t el;

4550 int i;

4551

4552 obstack_blank (&irp , els_in_cycle_reserv * sizeof (set_el_t));

4553 excl_set = (reserv_sets_t) obstack_base (&irp );

4554 obstack_finish (&irp );

4555 obstack_blank (&irp , description ->units_num * sizeof (reserv_sets_t));

4556 unit_excl_set_table = (reserv_sets_t *) obstack_base (&irp );

4557 obstack_finish (&irp );

4558 /* Evaluate unit exclusion sets. */

4559 for (i = 0; i < description ->decls_num; i++)

4560 {

4561 decl = description ->decls [i];

4562 if (decl->mode == dm_unit)

4563 {

4564 obstack_blank (&irp , els_in_cycle_reserv * sizeof (set_el_t));

4565 unit_excl_set = (reserv_sets_t) obstack_base (&irp );

4566 obstack_finish (&irp );

4567 memset (unit_excl_set, 0, els_in_cycle_reserv * sizeof (set_el_t));

4568 for (el = DECL_UNIT (decl)->excl_list;

4569 el != NULL;

4570 el = el->next_unit_set_el)

4571 {

4572 SET_BIT (unit_excl_set, el->unit_decl->unit_num);

4573 el->unit_decl->in_set_p = TRUE;

4574 }

4575 unit_excl_set_table [DECL_UNIT (decl)->unit_num] = unit_excl_set;

4576 }

4577 }

4578 }

4552 至 4554 行为 excl_set 分配内存，这个对象的内容将由 get_excl_set 来填充。 4555~4557 行则是为 unit_excl_set_table 分配内存，注意 reserv_sets_t 是 set_el_t 的指针类型。

前面在处理 decl的第四个循环 – DECL_EXCL 一节，整合了功能单元所有的互斥信息，这里就用上了。 4568 行的循环利用这个互斥信息设置 unit_excl_set_table 。

同样， unit_presence_set_table ， unit_presence_set_table ， unit_absence_set_table 及 unit_final_absence_set_table 也是通过类似的方式设置的。

4653 static void

4654 initiate_presence_absence_pattern_sets (void) in genautomata.c

4655 {

4656 decl_t decl;

4657 int i;

4658

4659 obstack_blank (&irp , description ->units_num * sizeof (pattern_reserv_t));

4660 unit_presence_set_table = (pattern_reserv_t *) obstack_base (&irp );

4661 obstack_finish (&irp );

4662 obstack_blank (&irp , description ->units_num * sizeof (pattern_reserv_t));

4663 unit_final_presence_set_table = (pattern_reserv_t *) obstack_base (&irp );

4664 obstack_finish (&irp );

4665 obstack_blank (&irp , description ->units_num * sizeof (pattern_reserv_t));

4666 unit_absence_set_table

4667

4668 = (pattern_reserv_t *) obstack_base (&irp );

4669 obstack_finish (&irp );

4670 obstack_blank (&irp , description ->units_num * sizeof (pattern_reserv_t));

4671 unit_final_absence_set_table = (pattern_reserv_t *) obstack_base (&irp );

4672 obstack_finish (&irp );

4673 /* Evaluate unit presence/absence sets. */

4674 for (i = 0; i < description ->decls_num; i++)

4675 {

4676 decl = description ->decls [i];

4677 if (decl->mode == dm_unit)

4678 {

4679 unit_presence_set_table [DECL_UNIT (decl)->unit_num]

4680 = form_reserv_sets_list (DECL_UNIT (decl)->presence_list);

4681 unit_presence_set_table [DECL_UNIT (decl)->unit_num]

4682 = form_reserv_sets_list (DECL_UNIT (decl)->final_presence_list);

4683 unit_absence_set_table [DECL_UNIT (decl)->unit_num]

4684 = form_reserv_sets_list (DECL_UNIT (decl)->absence_list);

4685 unit_final_absence_set_table [DECL_UNIT (decl)->unit_num]

4686 = form_reserv_sets_list (DECL_UNIT (decl)->final_absence_list);

4687 }

4688 }

4689 }

下面， automata_num 的值来自自动机生成命令中的选项“ -split ”。不过，在当前版本中它尚不被支持，参见 initiate_automaton_gen ， 9664 行。

6804 static void

6805 create_automata (void) in genautomata.c

6806 {

6807 automaton_t curr_automaton;

6808 automaton_t prev_automaton;

6809 decl_t decl;

6810 int curr_automaton_num;

6811 int i;

6812

6813 if (automata_num != 0)

6814 {

…

6830 }

6831 else

6832 {

6833 curr_automaton_num = 0;

6834 prev_automaton = NULL;

6835 for (i = 0; i < description ->decls_num; i++)

6836 {

6837 decl = description ->decls [i];

6838 if (decl->mode == dm_automaton

6839 && DECL_AUTOMATON (decl)->automaton_is_used)

6840 {

6841 curr_automaton = create_node (sizeof (struct automaton));

6842 curr_automaton->ainsn_list = create_ainsns ();

6843 curr_automaton->corresponding_automaton_decl

6844 = DECL_AUTOMATON (decl);

6845 curr_automaton->next_automaton = NULL;

6846 DECL_AUTOMATON (decl)->corresponding_automaton = curr_automaton;

6847 curr_automaton->automaton_order_num = curr_automaton_num;

6848 if (prev_automaton == NULL)

6849 description ->first_automaton = curr_automaton;

6850 else

6851 prev_automaton->next_automaton = curr_automaton;

6852 curr_automaton_num++;

6853 prev_automaton = curr_automaton;

6854 }

6855 }

6856 if (curr_automaton_num == 0)

6857 {

6858 curr_automaton = create_node (sizeof (struct automaton));

6859 curr_automaton->ainsn_list = create_ainsns ();

6860 curr_automaton->corresponding_automaton_decl = NULL;

6861 curr_automaton->next_automaton = NULL;

6862 description ->first_automaton = curr_automaton;

6863 }

6864 units_to_automata_distr ();

6865 }

6835 行的循环首先为所有的自动机创建 automaton 对象，这些对象具有如下定义。

1224 struct automaton in genautomata.c

1225 {

1226 /* The following field value is the list of insn declarations for

1227 given automaton. */

1228 ainsn_t ainsn_list;

1229 /* The following field value is the corresponding automaton

1230 declaration. This field is not NULL only if the automatic

1231 partition on automata is not used. */

1232 struct automaton_decl *corresponding_automaton_decl;

1233 /* The following field value is the next automaton. */

1234 automaton_t next_automaton;

1235 /* The following field is start state of FA. There are not unit

1236 reservations in the state. */

1237 state_t start_state;

1238 /* The following field value is number of equivalence classes of

1239 insns (see field `insn_equiv_class_num' in

1240 `insn_reserv_decl'). */

1241 int insn_equiv_classes_num;

1242 /* The following field value is number of states of final DFA. */

1243 int achieved_states_num;

1244 /* The following field value is the order number (0, 1, ...) of

1245 given automaton. */

1246 int automaton_order_num;

1247 /* The following fields contain statistics information about

1248 building automaton. */

1249 int NDFA_states_num, DFA_states_num;

1250 /* The following field value is defined only if minimization of DFA

1251 is used. */

1252 int minimal_DFA_states_num;

1253 int NDFA_arcs_num, DFA_arcs_num;

1254 /* The following field value is defined only if minimization of DFA

1255 is used. */

1256 int minimal_DFA_arcs_num;

1257 /* The following two members refer for two table state x ainsn ->

1258 int. */

1259 state_ainsn_table_t trans_table;

1260 state_ainsn_table_t state_alts_table;

1261 /* The following member value is maximal value of min issue delay

1262 for insns of the automaton. */

1263 int max_min_delay;

1264 /* Usually min issue delay is small and we can place several (2, 4,

1265 8) elements in one vector element. So the compression factor can

1266 be 1 (no compression), 2, 4, 8. */

1267 int min_issue_delay_table_compression_factor;

1268 };

205 typedef struct automaton *automaton_t ; in genautomata.c

在 automaton 定义中，域 ainsn_list 记录了所有会驱动这个自动机从一个状态到另一个状态的指令。而且我们将会看到，在自动机增长时， ainsn_list 还会记录涉及的状态。它是在 automaton 定义中最重要的域。在 6842 行， create_ainsns 为每个自动机构建这个链表。

6746 static ainsn_t

6747 create_ainsns (void) in genautomata.c

6748 {

6749 decl_t decl;

6750 ainsn_t first_ainsn;

6751 ainsn_t curr_ainsn;

6752 ainsn_t prev_ainsn;

6753 int i;

6754

6755 first_ainsn = NULL;

6756 prev_ainsn = NULL;

6757 for (i = 0; i < description ->decls_num; i++)

6758 {

6759 decl = description ->decls [i];

6760 if (decl->mode == dm_insn_reserv)

6761 {

6762 curr_ainsn = create_node (sizeof (struct ainsn ));

6763 curr_ainsn->insn_reserv_decl = DECL_INSN_RESERV (decl);

6764 curr_ainsn->important_p = FALSE;

6765 curr_ainsn->next_ainsn = NULL;

6766 if (prev_ainsn == NULL)

6767 first_ainsn = curr_ainsn;

6768 else

6769 prev_ainsn->next_ainsn = curr_ainsn;

6770 prev_ainsn = curr_ainsn;

6771 }

6772 }

6773 return first_ainsn;

6774 }

在 6762 行的 ainsn 具有如下定义。看到它与 define_insn_reservation 是一一对应的。

1179 struct ainsn in genautomata.c

1180 {

1181 /* The following field value is the corresponding insn declaration

1182 of description. */

1183 struct insn_reserv_decl *insn_reserv_decl;

1184 /* The following field value is the next insn declaration for an

1185 automaton. */

1186 ainsn_t next_ainsn;

1187 /* The following field is states which characterize automaton unit

1188 reservations of the instruction. The value can be NULL only if it

1189 is special insn `cycle advancing'. */

1190 alt_state_t alt_states;

1191 /* The following field is sorted list of states which characterize

1192 automaton unit reservations of the instruction. The value can be

1193 NULL only if it is special insn `cycle advancing'. */

1194 alt_state_t sorted_alt_states;

1195 /* The following field refers the next automaton insn with

1196 the same reservations. */

1197 ainsn_t next_same_reservs_insn;

1198 /* The following field is flag of the first automaton insn with the

1199 same reservations in the declaration list. Only arcs marked such

1200 insn is present in the automaton. This significantly decreases

1201 memory requirements especially when several automata are

1202 formed. */

1203 char first_insn_with_same_reservs;

1204 /* The following member has nonzero value if there is arc from state of

1205 the automaton marked by the ainsn. */

1206 char arc_exists_p;

1207 /* Cyclic list of insns of an equivalence class is formed with the

1208 aid of the following field. */

1209 ainsn_t next_equiv_class_insn;

1210 /* The following field value is nonzero if the insn declaration is

1211 the first insn declaration with given equivalence number. */

1212 char first_ainsn_with_given_equialence_num;

1213 /* The following field is number of class of equivalence of insns.

1214 It is necessary because many insns may be equivalent with the

1215 point of view of pipeline hazards. */

1216 int insn_equiv_class_num;

1217 /* The following member value is TRUE if there is an arc in the

1218 automaton marked by the insn into another state. In other

1219 words, the insn can change the state of the automaton. */

1220 int important_p;

1221 };

某些 define_insn_reservation 模式可能具有多个功能单元预订计划，这意味着，从某个状态出发，通过不同的计划，将导致不同的状态。域 alt_states 将记录这些从同一个状态开始的不同的状态迁移。在当前版本中，如果在机器描述文件中没有定义自动机，所有 CPU 单元将被分配到单个默认自动机，否则分配在机器描述文件中指定。 units_to_automata_distr 执行这个分配。

6778 static void

6779 units_to_automata_distr (void) in genautomata.c

6780 {

6781 decl_t decl;

6782 int i;

6783

6784 for (i = 0; i < description ->decls_num; i++)

6785 {

6786 decl = description ->decls [i];

6787 if (decl->mode == dm_unit)

6788 {

6789 if (DECL_UNIT (decl)->automaton_decl == NULL

6790 || (DECL_UNIT (decl)->automaton_decl->corresponding_automaton

6791 == NULL))

6792 /* Distribute to the first automaton. */

6793 DECL_UNIT (decl)->corresponding_automaton_num = 0;

6794 else

6795 DECL_UNIT (decl)->corresponding_automaton_num

6796 = (DECL_UNIT (decl)->automaton_decl

6797 ->corresponding_automaton->automaton_order_num);

6798 }

6799 }

6800 }

实际上设置了单元对象的 corresponding_automaton_num 域就完成了分配。

9.5.8.3. 构建位图及准备状态的数据

所有的资源都已经被分配了。是时候填充位图及构建包容替代的数据。注意即便只出现一个候选，出于统一处理的目的，这个数据仍然需要被创建。替代是从某个状态同时触发的分支，本质上它与非替代（ non-alternative ）没有什么不同。

create_automata (continued)

6866 NDFA_time = create_ticker ();

6867 ticker_off (&NDFA_time );

6868 NDFA_to_DFA_time = create_ticker ();

6869 ticker_off (&NDFA_to_DFA_time );

6870 minimize_time = create_ticker ();

6871 ticker_off (&minimize_time );

6872 equiv_time = create_ticker ();

6873 ticker_off (&equiv_time );

6874 for (curr_automaton = description ->first_automaton;

6875 curr_automaton != NULL;

6876 curr_automaton = curr_automaton->next_automaton)

6877 {

6878 if (progress_flag )

6879 {

6880 if (curr_automaton->corresponding_automaton_decl == NULL)

6881 fprintf (stderr , "Prepare anonymous automaton creation ... ");

6882 else

6883 fprintf (stderr , "Prepare automaton `%s' creation...",

6884 curr_automaton->corresponding_automaton_decl->name);

6885 }

6886 create_alt_states (curr_automaton);

6887 form_ainsn_with_same_reservs (curr_automaton);

6888 if (progress_flag )

6889 fprintf (stderr , "done/n");

6890 build_automaton (curr_automaton);

6891 enumerate_states (curr_automaton);

6892 ticker_on (&equiv_time );

6893 set_insn_equiv_classes (curr_automaton);

6894 ticker_off (&equiv_time );

6895 }

6896 }

我们前面已经看到， define_insn_reservation 定义了每个周期中资源的使用情况，而且已经分配了位图来记录每条指令每个周期的 CPU 单元的使用情况。当调度指令时，它将显示该指令是否会与其他已经被调度的指令争夺相同的资源，这对于构建聪明、高效的调度器很重要。 create_alt_states 为替代构建数据，并且为每个替代填充位图。

5589 static void

5590 create_alt_states (automaton_t automaton) in genautomata.c

5591 {

5592 struct insn_reserv_decl *reserv_decl;

5593

5594 for (curr_ainsn = automaton->ainsn_list;

5595 curr_ainsn != NULL;

5596 curr_ainsn = curr_ainsn ->next_ainsn)

5597 {

5598 reserv_decl = curr_ainsn ->insn_reserv_decl;

5599 if (reserv_decl != DECL_INSN_RESERV (advance_cycle_insn_decl ))

5600 {

5601 curr_ainsn ->alt_states = NULL;

5602 process_alts_for_forming_states (reserv_decl->transformed_regexp,

5603 automaton, 0);

5604 curr_ainsn ->sorted_alt_states

5605 = uniq_sort_alt_states (curr_ainsn ->alt_states);

5606 }

5607 }

5608 }

define_insn_reservation 的 regexp 已经被转换，把“ | ”移到最外面，在替代内部不应该看到“ | ”，即替代内部不会包含替代。下面的函数基于这样的假设（参见 5577 行）。

5556 static void

5557 process_alts_for_forming_states (regexp_t regexp, in genautomata.c

5558 automaton_t automaton, int inside_oneof_p)

5559 {

5560 int i;

5561

5562 if (regexp->mode != rm_oneof)

5563 {

5564 alt_state_being_formed = get_free_alt_state ();

5565 state_being_formed = get_free_state (1, automaton);

5566 alt_state_being_formed ->state = state_being_formed ;

5567 /* We inserts in reverse order but we process alternatives also

5568 i n reverse order. So we have the same order of alternative

5569 as in the description. */

5570 alt_state_being_formed ->next_alt_state = curr_ainsn ->alt_states;

5571 curr_ainsn ->alt_states = alt_state_being_formed ;

5572 (void) process_seq_for_forming_states (regexp, automaton, 0);

5573 finish_forming_alt_state (alt_state_being_formed , automaton);

5574 }

5575 else

5576 {

5577 if (inside_oneof_p)

5578 abort ();

5579 /* We processes it in reverse order to get list with the same

5580 order as in the description. See also the previous

5581 commentary. */

5582 for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)

5583 process_alts_for_forming_states (REGEXP_ONEOF (regexp)->regexps [i],

5584 automaton, 1);

5585 }

5586 }

上面在 5564 行， alt_state_being_formed 是一个 alt_state 的对象，它的定义在下面给出。这个数据为每个 define_insn_reservation 构成了一个链表，其 state 域记录了第一个替代的数据，而 next_alt_state 链接其它替代。 next_sorted_alt_state 保存排序了的替代的数据，这个数据用于区分不同的 define_insn_reservation 。

1165 struct alt_state in genautomata.c

1166 {

1167 /* The following field is a deterministic state which characterizes

1168 unit reservations of the instruction. */

1169 state_t state ;

1170 /* The following field refers to the next state which characterizes

1171 unit reservations of the instruction. */

1172 alt_state_t next_alt_state;

1173 /* The following field refers to the next state in sorted list. */

1174 alt_state_t next_sorted_alt_state;

1175 };

而在 1169 行， state_t 被 typedef 为 state * ，而 state 的定义如下。一开始，每个 define_insn_reservation 被与替代一一对应的 state 关联起来。在 1085 行， state 中的 reservs 域记录了每个周期的资源使用情况。

1078 struct state in genautomata.c

1079 {

1080 /* The following member value is nonzero if there is a transition by

1081 cycle advancing. */

1082 int new_cycle_p;

1083 /* The following field is list of processor unit reservations on

1084 each cycle. */

1085 reserv_sets_t reservs;

1086 /* The following field is unique number of given state between other

1087 states. */

1088 int unique_num;

1089 /* The following field value is automaton to which given state

1090 belongs. */

1091 automaton_t automaton;

1092 /* The following field value is the first arc output from given

1093 state. */

1094 arc_t first_out_arc;

1095 /* The following field is used to form NDFA. */

1096 char it_was_placed_in_stack_for_NDFA_forming;

1097 /* The following field is used to form DFA. */

1098 char it_was_placed_in_stack_for_DFA_forming;

1099 /* The following field is used to transform NDFA to DFA and DFA

1100 minimization. The field value is not NULL if the state is a

1101 compound state. In this case the value of field `unit_sets_list'

1102 is NULL. All states in the list are in the hash table. The list

1103 is formed through field `next_sorted_alt_state'. We should

1104 support only one level of nesting state. */

1105 alt_state_t component_states;

1106 /* The following field is used for passing graph of states. */

1107 int pass_num;

1108 /* The list of states belonging to one equivalence class is formed

1109 with the aid of the following field. */

1110 state_t next_equiv_class_state;

1111 /* The two following fields are used during minimization of a finite

1112 state automaton. */

1113 int equiv_class_num_1, equiv_class_num_2;

1114 /* The following field is used during minimization of a finite state

1115 automaton. The field value is state corresponding to equivalence

1116 class to which given state belongs. */

1117 state_t equiv_class_state;

1118 /* The following field value is the order number of given state.

1119 The states in final DFA is enumerated with the aid of the

1120 following field. */

1121 int order_state_num;

1122 /* This member is used for passing states for searching minimal

1123 delay time. */

1124 int state_pass_num;

1125 /* The following member is used to evaluate min issue delay of insn

1126 for a state. */

1127 int min_insn_issue_delay;

1128 /* The following member is used to evaluate max issue rate of the

1129 processor. The value of the member is maximal length of the path

1130 from given state no containing arcs marked by special insn `cycle

1131 advancing'. */

1132 int longest_path_length;

1133 };

process_seq_for_forming_states 则为每个替代构建当前周期的单元预订的位图（这里为周期 0 ）。

5484 static int

5485 process_seq_for_forming_states (regexp_t regexp, automaton_t automaton, in genautomata.c

5486 int curr_cycle)

5487 {

5488 int i;

5489

5490 if (regexp == NULL)

5491 return curr_cycle;

5492 else if (regexp->mode == rm_unit)

5493 {

5494 if (REGEXP_UNIT (regexp)->unit_decl->corresponding_automaton_num

5495 == automaton->automaton_order_num)

5496 set_state_reserv (state_being_formed , curr_cycle,

5497 REGEXP_UNIT (regexp)->unit_decl->unit_num);

5498 return curr_cycle;

5499 }

5500 else if (regexp->mode == rm_sequence)

5501 {

5502 for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)

5503 curr_cycle

5504 = process_seq_for_forming_states

5505 (REGEXP_SEQUENCE (regexp)->regexps [i], automaton, curr_cycle) + 1;

5506 return curr_cycle;

5507 }

5508 else if (regexp->mode == rm_allof)

5509 {

5510 int finish_cycle = 0;

5511 int cycle;

5512

5513 for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)

5514 {

5515 cycle = process_seq_for_forming_states (REGEXP_ALLOF (regexp)

5516 ->regexps [i],

5517 automaton, curr_cycle);

5518 if (finish_cycle < cycle)

5519 finish_cycle = cycle;

5520 }

5521 return finish_cycle;

5522 }

5523 else

5524 {

5525 if (regexp->mode != rm_nothing)

5526 abort ();

5527 return curr_cycle;

5528 }

5529 }

单元预订位图由 5496 行的 set_state_reserv 填充。这个位图使用 CPU 周期及 unit_num 做索引，这个位图由静态变量 state_being_formed 表示，并且在 5566 行 state_being_formed 被赋予 alt_state_being_formed ->state 。

4160 static void

4161 set_state_reserv (state_t state, int cycle_num, int unit_num) in genautomata.c

4162 {

4163 set_unit_reserv (state->reservs, cycle_num, unit_num);

4164 }

3826 static void

3827 set_unit_reserv (reserv_sets_t reservs, int cycle_num, int unit_num)

3828 {

3829 if (cycle_num >= max_cycles_num )

3830 abort ();

3831 SET_BIT (reservs, cycle_num * els_in_cycle_reserv

3832 * sizeof (set_el_t) * CHAR_BIT + unit_num);

3833 }

上面的 els_in_cycle_reserv 在 initiate_states 的 4238 行初始化。它代表 reservs 的大小。 reservs 是记录周期内单元预订的位图。注意到在这里 unit_num 来自 define_cpu_unit 的 decl 的 unit_num 域，它是由 gen_unit 赋予的唯一的值。

回到 process_alts_for_forming_states ， alt_state_being_formed 被 finish_forming_alt_state 插入 state_table 。

5533 static void

5534 finish_forming_alt_state (alt_state_t alt_state, in genautomata.c

5535 automaton_t automaton ATTRIBUTE_UNUSED)

5536 {

5537 state_t state_in_table;

5538 state_t corresponding_state;

5539

5540 corresponding_state = alt_state->state;

5541 state_in_table = insert_state (corresponding_state);

5542 if (state_in_table != corresponding_state)

5543 {

5544 free_state (corresponding_state);

5545 alt_state->state = state_in_table;

5546 }

5547 }

在构建了当前周期的位图之后， form_ainsn_with_same_reservs 遍历同一个自动机中所有代表 define_insn_reservation 的 ainsn 对象。变长数组 first_insns 记录使用不同单元预订的 ainsn ，在 5654 行看到， last_insns 则基本与 first_insns 相同，除非找到使用相同单元预订的另一个 ainsn 对象，彼时这些 ainsn 对象将 next_same_reservs_insn 链接起来，形成一个队列（ queue ）， last_insns 指向最后的 ainsn 对象。