GCC后端及汇编发布（27-续）

build_automaton (continued)

6418

if (progress_flag

)

6419

fprintf (stderr

, " done/n");

6420

ticker_off (&NDFA_time

);

6421

count_states_and_arcs
(automaton, &states_num, &arcs_num);

6422

automaton->NDFA_states_num = states_num;

6423

automaton->NDFA_arcs_num = arcs_num;

6424

ticker_on (&NDFA_to_DFA_time

);

6425

if (progress_flag

)

6426

{

6427

if (automaton->corresponding_automaton_decl
== NULL)

6428

fprintf (stderr

, "Make anonymous
DFA");

6429

else

6430

fprintf (stderr

, "Make DFA `%s'",

6431

automaton->corresponding_automaton_decl->name);

6432

fprintf (stderr

, " (1 dot is 100 new
states):");

6433

}

count_states_and_arcs

计算指定自动机的状态及迁移的数目。

6387

static
void

6388

count_states_and_arcs

(automaton_t
automaton, int *states_num,
in genautomata.c

6389

int *arcs_num)

6390

{

6391

curr_counted_states_num

= 0;

6392

curr_counted_arcs_num

= 0;

6393

pass_states
(automaton, incr_states_and_arcs_nums
);

6394

*states_num = curr_counted_states_num

;

6395

*arcs_num = curr_counted_arcs_num

;

6396

}

5978

static
void

5979

pass_states

(automaton_t
automaton, void (*applied_func) (state_t
state)) in genautomata.c

5980

{

5981

curr_state_graph_pass_num

++;

5982

pass_state_graph
(automaton->start_state, applied_func
);

5983

}

上面在
6394
行，
curr_state_graph_pass_num

确保每个状态将仅会被计算一次。在下面的
5966
行我们可以看到这一点。

5961

static
void

5962

pass_state_graph

(state_t
start_state, void (*applied_func) (state_t
state))
in genautomata.c

5963

{

5964

arc_t arc;

5965

5966

if (start_state->pass_num == curr_state_graph_pass_num

)

5967

return
;

5968

start_state->pass_num = curr_state_graph_pass_num

;

5969

(*applied_func
)
(start_state);

5970

for
(arc = first_out_arc
(start_state);

5971

arc != NULL;

5972

arc = next_out_arc (arc))

5973

pass_state_graph
(arc->to_state, applied_func);

5974

}

对于每个状态，调用
incr_states_and_arcs_nums

。

6376

static
void

6377

incr_states_and_arcs_nums

(state_t
state)
in
genautomata.c

6378

{

6379

arc_t arc;

6380

6381

curr_counted_states_num

++;

6382

for
(arc = first_out_arc
(state); arc != NULL; arc = next_out_arc (arc))

6383

curr_counted_arcs_num

++;

6384

}

现在是时候把
NDFA
转换为
DFA
了。继续看
build_automaton

。

build_automaton (continued)

6434

NDFA_to_DFA
(automaton);

6435

if (progress_flag

)

6436

fprintf (stderr

, " done/n");

6437

ticker_off (&NDFA_to_DFA_time

);

6438

count_states_and_arcs
(automaton, &states_num, &arcs_num);

6439

automaton->DFA_states_num = states_num;

6440

automaton->DFA_arcs_num = arcs_num;

6441

if (!no_minimization_flag

)

6442

{

6443

ticker_on (&minimize_time

);

6444

if (progress_flag

)

6445

{

6446

if
(automaton->corresponding_automaton_decl == NULL)

6447

fprintf (stderr, "Minimize
anonymous DFA...");

6448

else

6449

fprintf (stderr

,
"Minimize DFA `%s'...",

6450

automaton->corresponding_automaton_decl->name);

6451

}

6452

minimize_DFA
(automaton);

6453

if (progress_flag

)

6454

fprintf (stderr

, "done/n");

6455

ticker_off (&minimize_time

);

6456

count_states_and_arcs
(automaton, &states_num, &arcs_num);

6457

automaton->minimal_DFA_states_num =
states_num;

6458

automaton->minimal_DFA_arcs_num =
arcs_num;

6459

}

6460

}

在这里转换
NDFA
到
DFA
的算法很简单。对于我们的例子，从
start_state

状态出发，可以迁移到
SA
，
SB
或
SC
状态。为了解决这个非确定性，我们构建了一个新状态
A’
，
A’ = {SA
∪
SB
∪
SC} –
这意味着它是一个在状态
S
下由类别为
(A|B|C)
的指令所触发的组合状态，它具有所有从状态
SA
，
SB
及
SC
出发的迁移。看到这个从状态
S
到
A’
的迁移，现在是确定性的。对所有具有非确定性迁移的状态重复上述步骤，直到不存在这样的状态。

为了更好地清楚这个算法，考虑以下自动机。



图
74

：
NDFA
转换到
DFA
的例子，步骤
1

除了状态
S
以外，从每个状态出发，可以找到至少一个闭环
–
对于可行的芯片这是个必须条件，因为任意开放的节点意味着芯片将死在那一点上。并且注意到初始状态（
S
）不能有进入的迁移。这个自动机例子是一个
NDFA
，看到从状态
S
到状态
A1
的迁移是非确定性的。



图
75

：
NDFA
转换到
DFA
的例子，步骤
2

在状态
A1
及
A2
上应用这个算法，我们可以得到上图。状态
A12
仍然是非确定性的，因为指令类别
ib
可以触发两个迁移。看到状态
A12
是从状态
A1
及
A2
构建的复合状态，现在我们不能确定其单元预订了。不过，我们不再需要单元预订，我们所需要的仅是状态及其之间的迁移。



图
76

：
NDFA
转换到
DFA
的例子，步骤
3

又，合并状态
B1
及
B2
，我们得到上图，不过这个状态仍然是非确定性的，因为
advance_cycle_insn_decl

将触发两个状态迁移。看到这个状态
B12
甚至不能在前面自动机生成过程中存在。



图
77

：
NDFA
转换到
DFA
的例子，步骤
4

最后修改出的确定性自动机显示于上图。注意到这个确定性版本及非确定性版本，仅从指令发布机会的意义上而言，是相等的。

5917

static
void

5918

NDFA_to_DFA

(automaton_t
automaton)

5919

{

5920

state_t
start_state;

5921

state_t
state;

5922

decl_t
decl;

5923

vla_ptr_t state_stack;

5924

int i;

5925

int states_n;

5926

5927

VLA_PTR_CREATE (state_stack, 150, "state
stack");

5928

/* Create the start
state (empty state).
*/

5929

start_state = automaton->start_state;

5930

start_state->it_was_placed_in_stack_for_DFA_forming
= 1;

5931

VLA_PTR_ADD (state_stack, start_state);

5932

states_n = 1;

5933

while
(VLA_PTR_LENGTH (state_stack) != 0)

5934

{

5935

state = VLA_PTR (state_stack,
VLA_PTR_LENGTH (state_stack) - 1);

5936

VLA_PTR_SHORTEN (state_stack, 1);

5937

form_arcs_marked_by_insn
(state);

5938

for
(i = 0; i < description

->decls_num;
i++)

5939

{

5940

decl = description

->decls [i];

5941

if (decl->mode == dm_insn_reserv

5942

&& create_composed_state

5943

(state, DECL_INSN_RESERV
(decl)->arcs_marked_by_insn,

5944

&state_stack))

5945

{

5946

states_n++;

5947

if (progress_flag

&& states_n % 100 == 0)

5948

fprintf (stderr

, ".");

5949

}

5950

}

5951

}

5952

VLA_PTR_DELETE (state_stack);

5953

}

记住对于非确定性自动机，在我们上面的例子中，将评估
define_insn_reservation
中的每个替代；而对于确定性自动机，将仅评估第一个合格的替代。从这之后，这将形成很大的区别。事实上，当替代以确定性方式来处理时，构建出的自动机已经就是确定性的。

5787

static
void

5788

form_arcs_marked_by_insn

(state_t
state)

in
genautomata.c

5789

{

5790

decl_t

decl;

5791

arc_t arc;

5792

int i;

5793

5794

for
(i = 0; i < description

->decls_num; i++)

5795

{

5796

decl = description

->decls [i];

5797

if (decl->mode == dm_insn_reserv)

5798

DECL_INSN_RESERV (decl)->arcs_marked_by_insn
= NULL;

5799

}

5800

for
(arc =
first_out_arc (state); arc != NULL; arc = next_out_arc (arc))

5801

{

5802

if (arc->insn == NULL)

5803

abort ();

5804

arc->next_arc_marked_by_insn

5805

= arc->insn->insn_reserv_decl->arcs_marked_by_insn;

5806

arc->insn->insn_reserv_decl->arcs_marked_by_insn = arc;

5807

}

5808

}

在跨越发布包含替代的指令类别的状态中，为了把这些特殊的迁移与其它确定性迁移区分开来，
form_arcs_marked_by_insn

将通过
next_arc_marked_by_insn

域链接这些迁移（以
arc
的形式）。

在非确定性的例子中，对于
start_state

将得到如下。

对于指令类别（
E|F
）

arcSF->next_arc_marked_by_insn = NULL (arcSF->to_state =
stateSF)

arcSF->insn->insn_reserv_decl->arcs_marked_by_insn = arcSF

arcSE->next_arc_marked_by_insn = arcSF (arcSE->to_state =
stateSE)

arcSE->insn->insn_reserv_decl->arcs_marked_by_insn = arcSE
（最后的值）

对于指令类别（
A|B|C
）

arcSC->next_arc_marked_by_insn = NULL (arcSC->to_state =
stateSC)

arcSC->insn->insn_reserv_decl->arcs_marked_by_insn = arcSC

arcSB->next_arc_marked_by_insn = arcSC (arcSB->to_state = stateSB)

arcSB->insn->insn_reserv_decl->arcs_marked_by_insn = arcSB

arcSA->next_arc_marked_by_insn = arcSB (arcSA->to_state =
stateSA)

arcSA->insn->insn_reserv_decl->arcs_marked_by_insn = arcSA
（最后的值）

（注意到上面的两部分被
state

的
arc

的
next_out_arc

域链接起来）

在确定性的例子中，对于
start_state

将得到如下。

对于指令类别
A

arcSA->next_arc_marked_by_insn = NULL (arcSA->to_state =
stateSA)

arcSA->insn->insn_reserv_decl->arcs_marked_by_insn = arcSA

对于指令类别
E

arcSE->next_arc_marked_by_insn = NULL (arcSE->to_state =
stateSE)

arcSE->insn->insn_reserv_decl->arcs_marked_by_insn = arcSE

（注意到上面的两部分被
state

的
arc

的
next_out_arc

域链接起来）

显示在下图，
insn (x1|x2|x3)
代表在
define_insn_reservation
中具有三个替代：
x1
，
x2
及
x3
的指令类别。在图中两个
arcs_marked_by_insn

是对应不同
insn_reserv_decl
的域
–
对应
define_insn_reservations
模式的
decl
。



图
78

：
构建
DFA
，阶段
2

现在在
state_stack

里仅是
state_start

。对于确定性自动机，
create_composed_state

是简单的，因为
next_arc_marked_by_insn

总是
NULL
（参见
5853
行的检查）。它将把在
5382
行获取的
to_state

压入
state_stack

并返回。现在在
state_stack

里，是
SA
，
SE
。

在非确定性自动机的例子中，域
component_states

用于所谓的复合状态（例如，上图中的状态
A12
，
B12
，
xy
）。对于具有替代
A
，
B
，
C
的指令类别来说，第一个参数
original_state

是
start_state

，而第二个参数
arcs_marked_by_insn

指向上图中的
arcs_marked_by_insn

，它是
insn_reserv_decl – define_insn_reservation
模式的
decl
，中的域。

5814

static
int

5815

create_composed_state

(state_t
original_state, arc_t arcs_marked_by_insn,
in
genautomata.c

5816

vla_ptr_t *state_stack)

5817

{

5818

state_t
state;

5819

alt_state_t alt_state, curr_alt_state;

5820

alt_state_t new_alt_state;

5821

arc_t curr_arc;

5822

arc_t next_arc;

5823

state_t
state_in_table;

5824

state_t
temp_state;

5825

alt_state_t canonical_alt_states_list;

5826

int alts_number;

5827

int new_state_p = 0;

5828

5829

if (arcs_marked_by_insn == NULL)

5830

return
new_state_p;

5831

if
(arcs_marked_by_insn->next_arc_marked_by_insn == NULL)

5832

state = arcs_marked_by_insn->to_state;

5833

else

5834

{

5835

if (!ndfa_flag

)

5836

abort ();

5837

/* Create
composed state.
*/

5838

state = get_free_state (0,
arcs_marked_by_insn->to_state->automaton);

5839

curr_alt_state = NULL;

5840

for
(curr_arc = arcs_marked_by_insn;

5841

curr_arc != NULL;

5842

curr_arc =
curr_arc->next_arc_marked_by_insn)

5843

if
(curr_arc->to_state->component_states == NULL)

5844

{

5845

new_alt_state = get_free_alt_state ();

5846

new_alt_state->next_alt_state =
curr_alt_state;

5847

new_alt_state->state =
curr_arc->to_state;

5848

curr_alt_state = new_alt_state;

5849

}

5850

else

5851

for
(alt_state = curr_arc->to_state->component_states;

5852

alt_state != NULL;

5853

alt_state =
alt_state->next_sorted_alt_state)

5854

{

5855

new_alt_state = get_free_alt_state
();

5856

new_alt_state->next_alt_state =
curr_alt_state;

5857

new_alt_state->state =
alt_state->state;

5858

if
(alt_state->state->component_states != NULL)

5859

abort ();

5860

curr_alt_state = new_alt_state;

5861

}

5862

/* There are
not identical sets in the alt state list.

*/

5863

canonical_alt_states_list = uniq_sort_alt_states
(curr_alt_state);

5864

if
(canonical_alt_states_list->next_sorted_alt_state == NULL)

5865

{

5866

temp_state = state;

5867

state =
canonical_alt_states_list->state;

5868

free_state (temp_state);

5869

}

5870

else

5871

{

5872

state->component_states =
canonical_alt_states_list;

5873

state_in_table = insert_state (state);

5874

if (state_in_table != state)

5875

{

5876

if
(!state_in_table->it_was_placed_in_stack_for_DFA_forming)

5877

abort ();

5878

free_state (state);

5879

state = state_in_table;

5880

}

5881

else

5882

{

5883

if
(state->it_was_placed_in_stack_for_DFA_forming)

5884

abort ();

5885

new_state_p = 1;

5886

for
(curr_alt_state = state->component_states;

5887

curr_alt_state != NULL;

5888

curr_alt_state =
curr_alt_state->next_sorted_alt_state)

5889

for
(curr_arc = first_out_arc (curr_alt_state->state);

5890

curr_arc != NULL;

5891

curr_arc = next_out_arc (curr_arc))

5892

add_arc
(state, curr_arc->to_state, curr_arc->insn, 1);

5893

}

5894

arcs_marked_by_insn->to_state =
state;

5895

for
(alts_number = 0,

5896

curr_arc =
arcs_marked_by_insn->next_arc_marked_by_insn;

5897

curr_arc != NULL;

5898

curr_arc = next_arc)

5899

{

5900

next_arc =
curr_arc->next_arc_marked_by_insn;

5901

remove_arc (original_state,
curr_arc);

5902

alts_number++;

5903

}

5904

arcs_marked_by_insn->state_alts =
alts_number;

5905

}

5906

}

5907

if
(!state->it_was_placed_in_stack_for_DFA_forming)

5908

{

5909

state->it_was_placed_in_stack_for_DFA_forming
= 1;

5910

VLA_PTR_ADD (*state_stack, state);

5911

}

5912

return
new_state_p;

5913

}

在我们例子中，
curr_alt_state

是一个链表，形如：
curr_alt_state(SA)->next_alt_state(SB)->
next_alt_state(SC)
。然后这个链表被传递给
uniq_sort_alt_states

，这个函数排序
alt_states_list

，并从这个链表中移去重复的
alt_state
。在这里，对于我们的非确定性例子，这个链表没有改变。

在
5864
行，如果
next_sorted_alt_state

不是
NULL
，那么在
5872
行的
state

是新构建的，它必然不出现在
state_table

里，因此我们进入
5882
行。在
create_composed_state

中构建的数据显示如下图。



图
79

：
构建
DFA
，阶段
3

正如我们之前提及的，一旦构建了新状态，当前状态的所有替代的迁移目标，就被设置为这个新状态的迁移目标。然后当前状态，在理论上，可以确定性地迁移到这个新状态，注意到在图中
arcSA
被留下了，蓝色的域被修改了；而其它用于当前状态替代的
arc
都被移除了。接着，这个新状态将被压入
state_stack

。然后在这个状态上重复上面的步骤。直到
state_stack

中没有状态（即，没有状态具有非确定性迁移），
NDFA_to_DFA

才退出。