GCC后端及汇编发布（6）

3.3.

构建识别树

3.3.3.

创建识别树

对于每个指令描述模式（正如我们看到有
3
个类型的模式在使用——
define_insn
，
define_split
及
define_peephole2
。但是它们被分别处理，因此有
3
种树对应这
3
个类型的模式），将构建形如
图

13

的树。为了从这些树，以高效、方便的方式，产生
insn-recog.c
，我们需要把这些树合并成一棵大的树。这正是
merge_trees

.
的目的。对于所有的描述，
merge_trees

应该构建一棵如下的树。



图

14

：
由
merge_trees
创建的描述树

图

14

的树（目标树）从指令的第一棵描述树，通过加入其它描述树，生长起来。对于这些树，它们将与目标树，从根节点开始，进行比较。在那些目标树中的节点不同于描述树节点的位置，该描述树节点将被作为目标树节点的兄弟节点加入。而如果目标树节点被发现与描述树节点相同，就进入这两棵树的下一级节点（在这两棵树中，深度由
decision
节点的
position

域，以我们在上面看到的方式，来显示），然后重复比较，合并或深入的步骤。

显然，每个指令与目标树的某个叶子匹配，注意到叶子与指令是一一对应的。从根节点到特定的叶子，其路径代表了用于选择该指令的条件测试。

1397

static
void

1398

merge_trees (struct
decision_head
*oldh, struct
decision_head *addh)
in genrecog.c

1399

{

1400

struct
decision
*next, *add;

1401

1402

if (addh->first == 0)

1403

return
;

1404

if (oldh->first == 0)

1405

{

1406

*oldh = *addh;

1407

return
;

1408

}

1409

1410

/* Trying to merge
bits at different positions isn't possible.

*/

1411

if (strcmp (oldh->first->position,
addh->first->position))

1412

abort ();

1413

1414

for
(add =
addh->first; add ; add = next)

1415

{

1416

struct
decision
*old, *insert_before = NULL;

1417

1418

next = add->next;

1419

1420

/* The semantics
of pattern matching state that the tests are

1421

done in the order given in the MD file so
that if an insn

1422

matches two patterns, the first one will
be used. However,

1423

i
n practice, most, if not all, patterns are unambiguous so

1424

that their order is independent. In that
case, we can merge

1425

identical tests and group all similar
modes and codes together.

1426

1427

Scan starting from the end of OLDH until
we reach a point

1428

where we reach the head of the list or
where we pass a

1429

pattern that could also be true if NEW is
true. If we find

1430

an identical pattern, we can merge them.
Also, record the

1431

last node that tests the same code and
mode and the last one

1432

that tests just the same mode.

1433

1434

If we have no match, place NEW after the
closest match we found.
*/

1435

1436

for
(old =
oldh->last; old; old = old->prev)

1437

{

1438

if (nodes_identical
(old, add))

1439

{

1440

merge_accept_insn
(old, add);

1441

merge_trees
(&old->success, &add->success);

1442

goto
merged_nodes;

1443

}

1444

1445

if (maybe_both_true
(old, add, 0))

1446

break
;

1447

1448

/* Insert the nodes in DT test type order,
which is roughly

1449

how expensive/important the test is.
Given that the tests

1450

are also ordered within the list,
examining the first is

1451

sufficient.
*/

1452

if ((int) add->tests->type <
(int) old->tests->type)

1453

insert_before = old;

1454

}

1455

1456

if (insert_before == NULL)

1457

{

1458

add->next = NULL;

1459

add->prev = oldh->last;

1460

oldh->last->next = add;

1461

oldh->last = add;

1462

}

1463

else

1464

{

1465

if ((add->prev =
insert_before->prev) != NULL)

1466

add->prev->next = add;

1467

else

1468

oldh->first = add;

1469

add->next = insert_before;

1470

insert_before->prev = add;

1471

}

1472

1473

merged_nodes:
;

1474

}

1475

}

这是一个非常复杂的过程，让我们一步一步来。在
main

中的调用点，我们看到该函数的第一个参数
oldh

指向我们例子的
recog_tree

，而第二个参数
addh

指向
图

13

所示的树。首先，它将检查以下的节点。



图
15

：
merge_tree
函数，图
1

在
1438
行，函数
nodes_identical

将检查上面的
decision
节点，来确定它们是否是相同的对象。而现在在
1436
行
oldh

的
prev

域，及在
1418
行
addh

的
next

域，都是
null
。

1317

static
int

1318

nodes_identical (struct
decision
*d1, struct
decision
*d2)

in
genrecog.c

1319

{

1320

struct

decision_test

*t1, *t2;

1321

1322

for
(t1 = d1->tests, t2 = d2->tests; t1
&& t2; t1 = t1->next, t2 = t2->next)

1323

{

1324

if (t1->type != t2->type)

1325

return
0;

1326

if (! nodes_identical_1 (t1, t2))

1327

return
0;

1328

}

1329

1330

/* For success,
they should now both be null.
*/

1331

if (t1 != t2)

1332

return
0;

1333

1334

/* Check that their
subnodes are at the same position, as any one set

1335

of sibling decisions must be at the same
position. Allowing this

1336

requires complications to find_afterward
and when change_state is

1337

invoked.

*/

1338

if (d1->success.first

1339

&& d2->success.first

1340

&& strcmp
(d1->success.first->position, d2->success.first->position))

1341

return
0;

1342

1343

return
1;

1344

}

上面，在
1326
行，在比较了类型之后，
nodes_identical_1

进一步检查内容是否匹配。接着在
1338
行，要完全相同，跟随它们的节点的
position

也必须是相同的。显然我们例子中所关注的节点是相同的。

给定两个声明完全相同的节点，在
1440
行的函数
merge_accept_insn

拷贝这两个指令的接受状态。下面的
DT_accept_insn
表示一旦通过这个
decision_test
，对应的指令被匹配。即，这个
decision_test
节点是匹配这个指令的最后一个测试。

1353

static
void

1354

merge_accept_insn (struct
decision
*oldd, struct
decision
*addd)
in
genrecog.c

1355

{

1356

struct
decision_test
*old, *add;

1357

1358

for
(old =
oldd->tests; old; old = old->next)

1359

if (old->type == DT_accept_insn)

1360

break
;

1361

if (old == NULL)

1362

return
;

1363

1364

for
(add =
addd->tests; add; add = add->next)

1365

if (add->type == DT_accept_insn)

1366

break
;

1367

if (add == NULL)

1368

return
;

1369

1370

/* If one node is
for a normal insn and the second is for the base

1371

insn with clobbers stripped off, the second
node should be ignored.
*/

1372

1373

if (old->u.insn.num_clobbers_to_add == 0

1374

&&
add->u.insn.num_clobbers_to_add > 0)

1375

{

1376

/* Nothing to do
here.
*/

1377

}

1378

else if (old->u.insn.num_clobbers_to_add
> 0

1379

&& add->u.insn.num_clobbers_to_add == 0)

1380

{

1381

/* In this case,
replace OLD with ADD.
*/

1382

old->u.insn = add->u.insn;

1383

}

1384

else

1385

{

1386

message_with_line (add->u.insn.lineno,
"`%s' matches `%s'",

1387

get_insn_name
(add->u.insn.code_number),

1388

get_insn_name
(old->u.insn.code_number));

1389

message_with_line (old->u.insn.lineno,
"previous definition of `%s'",

1390

get_insn_name
(old->u.insn.code_number));

1391

error_count

++;

1392

}

1393

}

上面的
num_clobbers_to_add

，在
make_insn_sequence

中，设置为
PARALLEL
对象中元素数目的记录。如果它们在是否带
clobber
上不相同，那么这个冲突是由
make_insn_sequence

造成的，我们可以丢掉带有
clobber
的版本。如果这两个节点不能通过
clobber
来区分，我们在机器描述文件中找到了一个二义性错误。这个机制用于筛选更有效率的指令。

对于两个相同的节点，那样
merge_trees

沿着链，递归入下一个节点。我们可以看到，对于这两个链，接着的节点也是相同的，直到来到以下节点。



图
16

：
merge_tree
函数，图
2

对于这两个节点，
nodes_identical

在
DT_Code
类型的
decision_test
的子节点处返回
0
。然后函数
maybe_both_true

将被调用。这个函数把描述树的节点与目标树的兄弟节点比较，如果任一兄弟节点匹配这个节点就返回
1
，如果没有找到这样的兄弟节点就返回
0
，不确定则返回
-1
。

1202

static
int

1203

maybe_both_true (struct
decision
*d1, struct
decision
*d2,
in
genrecog.c

1204

int toplevel)

1205

{

1206

struct
decision
*p1, *p2;

1207

int cmp;

1208

1209

/* Don't compare strings on the different
positions in insn. Doing so

1210

is incorrect and results in false matches
from constructs like

1211

1212

[(set (subreg:HI (match_operand:SI
"register_operand" "r") 0)

1213

(subreg:HI (match_operand:SI
"register_operand" "r") 0))]

1214

vs

1215

[(set (match_operand:HI
"register_operand" "r")

1216

(match_operand:HI "register_operand"
"r"))]

1217

1218

If we are presented with such, we are
recursing through the remainder

1219

of a node's success nodes (from the loop at
the end of this function).

1220

Skip forward until we come to a position
that matches.

1221

1222

Due to the way position strings are
constructed, we know that iterating

1223

forward from the lexically lower position
(e.g. "00") will run into

1224

the lexically higher position (e.g.
"1") and not the other way around.

1225

This saves a bit of effort.
*/

1226

1227

cmp = strcmp (d1->position,
d2->position);

1228

if (cmp != 0)

1229

{

1230

if (toplevel)

1231

abort ();

1232

1233

/* If the
d2->position was lexically lower, swap.

*/

1234

if (cmp > 0)

1235

p1
= d1, d1 = d2, d2 = p1;

1236

1237

if (d1->success.first == 0)

1238

return
1;

1239

for
(p1 =
d1->success.first; p1; p1 = p1->next)

1240

if (maybe_both_true
(p1, d2, 0))

1241

return
1;

1242

1243

return
0;

1244

}

1245

1246

/* Test the current
level.
*/

1247

cmp = maybe_both_true_1
(d1->tests, d2->tests);

1248

if (cmp >= 0)

1249

return
cmp;

1250

1251

/* We can't prove that D1 and D2 cannot both
be true. If we are only

1252

to check the top level, return 1.
Otherwise, see if we can prove

1253

that all choices in both successors are
mutually exclusive. If

1254

either does not have any successors, we
can't prove they can't both

1255

be true.

*/

1256

1257

if (toplevel || d1->success.first == 0 ||
d2->success.first == 0)

1258

return
1;

1259

1260

for
(p1 =
d1->success.first; p1; p1 = p1->next)

1261

for
(p2 =
d2->success.first; p2; p2 = p2->next)

1262

if (maybe_both_true
(p1, p2, 0))

1263

return
1;

1264

1265

return
0;

1266

}

然后
merge_trees

开始处理
position(‘10’)
的节点。对于这些节点，在
1227
行的测试将可通过。它们具有相同的位置。接着函数
maybe_both_true_1

测试属于这两个节点的
decision_test
，来确保这些测试集是相同的。如果匹配，它将返回
1
，可能匹配则返回
-1
，不匹配则返回
0
。

1168

static
int

1169

maybe_both_true_1 (struct
decision_test
*d1, struct
decision_test
*d2)
in genrecog.c

1170

{

1171

struct
decision_test
*t1, *t2;

1172

1173

/* A match_operand
with no predicate can match anything. Recognize

1174

this by the existence of alone DT_accept_op
test.

*/

1175

if
(d1->type == DT_accept_op || d2->type == DT_accept_op)

1176

return
1;

1177

1178

/* Eliminate pairs
of tests while they can exactly match.

*/

1179

while
(d1
&& d2 && d1->type == d2->type)

1180

{

1181

if (maybe_both_true_2
(d1, d2) == 0)

1182

return
0;

1183

d1 = d1->next, d2 = d2->next;

1184

}

1185

1186

/* After that, consider
all pairs.

*/

1187

for
(t1 = d1; t1 ; t1 = t1->next)

1188

for
(t2 = d2; t2 ; t2 = t2->next)

1189

if (maybe_both_true_2
(t1, t2) == 0)

1190

return
0;

1191

1192

return
-1;

1193

}

maybe_both_true_2

处理测试集中的具体测试。如果两个测试是相同的，它返回
1
；如果不同，则返回
0
；如果不能证明它们是相同的，就返回
-1
。

1058

static
int

1059

maybe_both_true_2 (struct
decision_test
*d1, struct
decision_test
*d2)
in genrecog.c

1060

{

1061

if (d1->type == d2->type)

1062

{

1063

switch
(d1->type)

1064

{

1065

case
DT_mode:

1066

return
d1->u.mode == d2->u.mode;

1067

1068

case
DT_code:

1069

return
d1->u.code == d2->u.code;

1070

1071

case
DT_veclen:

1072

return
d1->u.veclen == d2->u.veclen;

1073

1074

case
DT_elt_zero_int:

1075

case
DT_elt_one_int:

1076

case
DT_elt_zero_wide:

1077

case
DT_elt_zero_wide_safe:

1078

return
d1->u.intval == d2->u.intval;

1079

1080

default
:

1081

break
;

1082

}

1083

}

1084

1085

/* If either has a
predicate that we know something about, set

1086

things up so that D1 is the one that always
has a known

1087

predicate. Then see if they have any codes
in common.
*/

1088

1089

if (d1->type == DT_pred || d2->type ==
DT_pred)

1090

{

1091

if (d2->type == DT_pred)

1092

{

1093

struct
decision_test
*tmp;

1094

tmp = d1, d1 = d2, d2 = tmp;

1095

}

1096

1097

/* If D2 tests a mode, see if it matches
D1.
*/

1098

if (d1->u.pred.mode != VOIDmode)

1099

{

1100

if (d2->type == DT_mode)

1101

{

1102

if (d1->u.pred.mode != d2->u.mode

1103

/* The mode of an
address_operand predicate is the

1104

mode of the memory, not the
operand. It can only

1105

be used for testing the predicate,
so we must

1106

ignore it here.
*/

1107

&& strcmp (d1->u.pred.name,
"address_operand") != 0)

1108

return
0;

1109

}

1110

/* Don't check
two predicate modes here, because if both predicates

1111

accept CONST_INT, then both can still
be true even if the modes

1112

are different. If they don't accept
CONST_INT, there will be a

1113

separate DT_mode that will make
maybe_both_true_1 return 0.
*/

1114

}

1115

1116

if (d1->u.pred.index >= 0)

1117

{

1118

/* If D2 tests
a code, see if it is in the list of valid

1119

codes for D1's predicate.
*/

1120

if (d2->type == DT_code)

1121

{

1122

const
RTX_CODE *c = &preds

[d1->u.pred.index].codes[0];

1123

while
(*c != 0)

1124

{

1125

if (*c == d2->u.code)

1126

break
;

1127

++c;

1128

}

1129

if (*c == 0)

1130

return
0;

1131

}

1132

1133

/* Otherwise
see if the predicates have any codes in common.

*/

1134

else if (d2->type == DT_pred
&& d2->u.pred.index >= 0)

1135

{

1136

const
RTX_CODE *c1 = &preds

[d1->u.pred.index].codes[0];

1137

int common = 0;

1138

1139

while
(*c1 != 0 && !common)

1140

{

1141

const
RTX_CODE *c2 = &preds

[d2->u.pred.index].codes[0];

1142

while
(*c2
!= 0 && !common)

1143

{

1144

common = (*c1 == *c2);

1145

++c2;

1146

}

1147

++c1;

1148

}

1149

1150

if (!common)

1151

return
0;

1152

}

1153

}

1154

}

1155

1156

/* Tests vs veclen
may be known when strict equality is involved.

*/

1157

if
(d1->type == DT_veclen && d2->type == DT_veclen_ge)

1158

return
d1->u.veclen >= d2->u.veclen;

1159

if
(d1->type == DT_veclen_ge && d2->type == DT_veclen)

1160

return
d2->u.veclen >= d1->u.veclen;

1161

1162

return
-1;

1163

}

对于这里感兴趣的节点，
maybe_both_true_2

将对第二个子节点返回
0
，它进而使得在
1182
行的
maybe_both_true_1

返回
0
。接着函数
maybe_both_true

在
1249
行也返回
0
。

那么回到
merge_trees

，在
1445
行，因为
maybe_both_true

返回
0
。在
1452
行的代码执行在两个相等的类型上。那么在
1456
行，
insert_before

当前是
null
。在执行了
1456
行的
IF

块之后，我们可以得到如下的节点。两个位置是“
10
”的节点被链接为兄弟节点。



图
17

：
merge_tree
函数，图
3

从这个图中，我们可以看到，向
recog_tree

加入了一个分枝。看到事实上从
addh

剥除了公共的部分，对
recog_tree

的根节点，它们不可到达。

main (continued)

2662

if (error_count

)

2663

return
FATAL_EXIT_CODE;

2664

2665

puts ("/n/n");

2666

2667

process_tree
(&recog_tree, RECOG);

2668

process_tree
(&split_tree, SPLIT);

2669

process_tree
(&peephole2_tree, PEEPHOLE2);

2670

2671

fflush (stdout);

2672

return
(ferror (stdout) !=
0 ?
FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);

2673

}