GCC后端及汇编发布（5）

3.2.3.

向决策序列加入模式的
RTL
模板

对于上面我们的
define_insn
例子，在
2467
行，被传给
add_to_sequence

的类型是
RECOG
。而参数
pattern

是这个
define_insn
模式的
RTL
模板。对于我们的例子是：

[(set (reg 17)

(compare
(match_operand:DI 0 "nonimmediate_operand" "r,?mr")

(match_operand:DI 1 "const0_operand"
"n,n")))]

767

static
struct
decision
*

768

add_to_sequence
(rtx pattern, struct
decision_head
*last,
in genrecog.c

769

const
char *position, enum
routine_type insn_type, int top)

770

{

771

RTX_CODE code;

772

struct
decision
*this, *sub;

773

struct
decision_test
*test;

774

struct
decision_test
**place;

775

char *subpos;

776

size_t i;

777

const
char *fmt;

778

int depth = strlen (position);

779

int len;

780

enum
machine_mode mode;

781

782

if (depth > max_depth

)

783

max_depth

= depth;

784

785

subpos = xmalloc (depth + 2);

786

strcpy (subpos, position);

787

subpos[depth + 1] = 0;

788

789

sub = this = new_decision
(position, last);

790

place = &this->tests;

791

792

restart:

793

mode = GET_MODE (pattern);

794

code = GET_CODE (pattern);

795

796

switch
(code)

797

{

798

case
PARALLEL:

…

819

break
;

820

821

case
MATCH_PARALLEL:

…

831

case
MATCH_OPERAND:

832

case
MATCH_SCRATCH:

833

case
MATCH_OPERATOR:

834

case
MATCH_INSN:

835

{

…

915

}

916

917

case
MATCH_OP_DUP:

…

932

goto
fini;

933

934

case
MATCH_DUP:

935

case
MATCH_PAR_DUP:

936

code = UNKNOWN;

937

938

test = new_decision_test
(DT_dup,
&place);

939

test->u.dup = XINT (pattern, 0);

940

goto
fini;

941

942

case
ADDRESS:

943

pattern = XEXP (pattern, 0);

944

goto
restart;

945

946

default
:

947

break
;

948

}

当以
SET
码进入这个函数时，它将进入
946
行的
default
语句。在这个层次上，参数
position

是一个空字符串（
“”
）。并且注意到在
789
行，变量
sub

及
test

指向相同的新分配的决策实例。参见下面的
new_decision

。

316

static
struct
decision
*

317

new_decision (const
char *position, struct
decision_head *last)
in
genrecog.c

318

{

319

struct
decision
*new = xcalloc (1, sizeof
(struct
decision));

320

321

new->success = *last;

322

new->position = xstrdup (position);

323

new->number = next_number

++;

324

325

last->first = last->last = new;

326

return
new;

327

}

在
789
行，传递给
new_decision

的第二个参数是在
make_insn_sequence

的
2421
行声明的变量
head

。这个新的
decision
从头部链入，正如下图所示。



图
5

：
向决策序列加入
RTL
模板，图
1

add_to_sequence (continued)

950

fmt = GET_RTX_FORMAT (code);

951

len = GET_RTX_LENGTH (code);

952

953

/* Do tests against the current node
first.

*/

954

for
(i = 0; i < (size_t) len; i++)

955

{

956

if (fmt[i] == 'i')

957

{

958

if (i == 0)

959

{

960

test = new_decision_test
(DT_elt_zero_int, &place);

961

test->u.intval = XINT
(pattern, i);

962

}

963

else if (i == 1)

964

{

965

test = new_decision_test
(DT_elt_one_int, &place);

966

test->u.intval = XINT
(pattern, i);

967

}

968

else

969

abort ();

970

}

971

else if (fmt[i] == 'w')

972

{

973

/* If this value actually fits in an int, we
can use a switch

974

statement here, so indicate that.
*/

975

enum
decision_type
type

976

= ((int) XWINT
(pattern, i) == XWINT
(pattern, i))

977

? DT_elt_zero_wide_safe :
DT_elt_zero_wide;

978

979

if (i != 0)

980

abort ();

981

982

test = new_decision_test
(type,
&place);

983

test->u.intval = XWINT
(pattern, i);

984

}

985

else if (fmt[i] == 'E')

986

{

987

if (i != 0)

988

abort ();

989

990

test = new_decision_test
(DT_veclen,
&place);

991

test->u.veclen = XVECLEN (pattern, i);

992

}

993

}

在这里，我们再一次根据其格式处理模式。对于格式中的每个元素，通过
new_decision_test

构建了一个
decision_test
的实例。它定义了将要进行的测试。

331

static
struct
decision_test
*
in
genrecog.c

332

new_decision_test
(enum
decision_type
type, struct
decision_test
***pplace)

333

{

334

struct
decision_test
**place = *pplace;

335

struct
decision_test
*test;

336

337

test = xmalloc (sizeof
(*test));

338

test->next = *place;

339

test->type = type;

340

*place = test;

341

342

place = &test->next;

343

*pplace = place;

344

345

return
test;

346

}

上面，在这里传递给
new_decision_test

的第二个参数——声明在
add_to_sequence

的
790
行的变量
place

，指向变量
this

的
tests

域，这个变量是在
add_to_sequence

的
789
行构建的一个
decision
实例，同时在
make_insn_sequence

的
2421
行
this

链入以变量
head

开头的链表。

这个函数看起来有点晕，让我们一步一步来看。



图
6

：
new_decision_test
，步骤
1

直到
339
行，我们可以得到如上图所示的数据。看到新构建的
decision_test
的
next

域指向旧的
decision_test
。那么在
440
行，
pplace

，
place

及
this->tests

都指向这个新节点，如下图所示。



图
7

：
new_decision_test
，步骤
2

在
new_decision_test

的余下部分，
place

及
pplace

将指向新节点的
next

域的地址，如下图所示。



图
8

：
new_decision_test
，步骤
3

然后对于下一个加入的节点（黄色），直到
340
行，我们可以得到以下图形。



图
9

：
new_decision_test
，步骤
4

最后，
pplace

，
place

将指向这个新加入的节点（黄色）。



图
10

：
new_decision_test
，步骤
5

从这些图形，我们可以看到对于进一步加入的节点，它们将被插入到初始节点与上一个被加入节点之间。这意味着对于加入节点序列
1
，
2
，
3
，
…
，
n
，我们将得到以下的列表：

This
à

tests
à

1
à

2
à

3…
à

n
à

初始节点

对于我们的情形，
rtx
对象
SET
具有格式‘
ee
’，
954
到
993
行的
FOR
块将不做任何事。

add_to_sequence (continued)

995

/* Now test our sub-patterns.

*/

996

for
(i = 0; i < (size_t) len; i++)

997

{

998

switch
(fmt[i])

999

{

1000

case
'e':
case
'u':

1001

subpos[depth] = '0' + i;

1002

sub = add_to_sequence
(XEXP
(pattern, i), &sub->success,

1003

subpos, insn_type,
0);

1004

break
;

1005

1006

case
'E':

1007

{

1008

int j;

1009

for
(j = 0; j < XVECLEN (pattern, i);
j++)

1010

{

1011

subpos[depth] = 'a' + j;

1012

sub = add_to_sequence
(XVECEXP (pattern, i, j),

1013

&sub->success, subpos, insn_type, 0);

1014

}

1015

break
;

1016

}

1017

1018

case
'i':
case
'w':

1019

/* Handled
above.
*/

1020

break
;

1021

case
'0':

1022

break
;

1023

1024

default
:

1025

abort ();

1026

}

1027

}

在
954
行的
FOR

块之后，是另一个
FOR

块。对于我们的例子，它将进入
1000
行的
CASE

块。在
1001
行的
subpos

保存了这个递归的深度信息。它包含了形如“
0123abc45ab
”的信息，其中数字用于显示格式元素的序列，而字母用于显示对应某些格式（即‘
E
’，‘
V
’）的
rtx
向量的序列。然后为这个
SET
对象的两个孩子调用
add_to_sequence

。

对于第一个孩子
reg

对象，在
add_to_sequence

中，它直接跑到
fini

标签处。因为其编码是
REG
，在
1035
行构建了一个新的
decision_test
，并在
decision

中，链入在其父亲的之后。而且对于我们的
reg

对象，其
mode
是
VOIDmode
，正如我们之前看到的。

对于第二个孩子
compare

对象，它的处理路径与
set

对象相同。在
1000
行它为其孩子调用
add_to_sequence

。

add_to_sequence (continued)

1029

fini:

1030

/* Insert nodes
testing mode and code, if they're still relevant,

1031

before any of the nodes we may have added
above.
*/

1032

if (code != UNKNOWN)

1033

{

1034

place = &this->tests;

1035

test = new_decision_test
(DT_code, &place);

1036

test->u.code = code;

1037

}

1038

1039

if
(mode != VOIDmode)

1040

{

1041

place = &this->tests;

1042

test = new_decision_test
(DT_mode, &place);

1043

test->u.mode = mode;

1044

}

1045

1046

/* If we didn't
insert any tests or accept nodes, hork.

*/

1047

if (this->tests == NULL)

1048

abort ();

1049

1050

ret:

1051

free (subpos);

1052

return
sub;

1053

}

现在对于在这个
compare

对象的第二个孩子，其编码是
MATCH_OPERAND
，将进入
add_to_sequence

中以下部分的代码。

add_to_sequence (continued)

831

case
MATCH_OPERAND:

832

case
MATCH_SCRATCH:

833

case
MATCH_OPERATOR:

834

case
MATCH_INSN:

835

{

836

const
char *pred_name;

837

RTX_CODE was_code = code;

838

int allows_const_int = 1;

839

840

if (code == MATCH_SCRATCH)

841

{

842

pred_name =
"scratch_operand";

843

code = UNKNOWN;

844

}

845

else

846

{

847

pred_name = XSTR (pattern, 1);

848

if (code == MATCH_PARALLEL)

849

code = PARALLEL;

850

else

851

code = UNKNOWN;

852

}

853

854

if (pred_name[0] != 0)

855

{

856

test = new_decision_test
(DT_pred, &place);

857

test->u.pred.name = pred_name;

858

test->u.pred.mode = mode;

859

860

/* See if we
know about this predicate and save its number.

861

If we do, and it only accepts one
code, note that fact.

862

863

If we know that the predicate does
not allow CONST_INT,

864

we know that the only way the
predicate can match is if

865

the modes match (here we use the
kludge of relying on the

866

fact that "address_operand"
accepts CONST_INT; otherwise,

867

it would have to be a special case),
so we can test the

868

mode (but we need not). This fact
should considerably

869

simplify the generated code.
*/

870

871

for
(i
= 0; i < NUM_KNOWN_PREDS; i++)

872

if (! strcmp (preds

[i].name, pred_name))

873

break
;

874

875

if (i < NUM_KNOWN_PREDS)

876

{

877

int j;

878

879

test->u.pred.index = i;

880

881

if (preds

[i].codes[1] == 0 &&
code == UNKNOWN)

882

code = preds

[i].codes[0];

883

884

allows_const_int = 0;

885

for
(j = 0; preds

[i].codes[j]
!= 0; j++)

886

if (preds

[i].codes[j] == CONST_INT)

887

{

888

allows_const_int = 1;

889

break
;

890

}

891

}

892

else

893

test->u.pred.index = -1;

894

}

895

896

/* Can't enforce a mode if we allow
const_int.
*/

897

if (allows_const_int)

898

mode = VOIDmode;

899

900

/* Accept the
operand, ie. record it in `operands'.
*/

901

test = new_decision_test
(DT_accept_op, &place);

902

test->u.opno = XINT
(pattern, 0);

903

904

if (was_code == MATCH_OPERATOR ||
was_code == MATCH_PARALLEL)

905

{

906

char base = (was_code == MATCH_OPERATOR
? '0' : 'a');

907

for
(i
= 0; i < (size_t) XVECLEN (pattern, 2); i++)

908

{

909

subpos[depth] = i + base;

910

sub = add_to_sequence
(XVECEXP (pattern, 2, i),

911

&sub->success,
subpos, insn_type, 0);

912

}

913

}

914

goto
fini;

915

}

这个代码类似于
validate_pattern

的那部分。当我们的例子模式通过这个函数时，我们可以得到以下的树。



图
11

：向决策序列加入
RTL
模板，图
2

然后我们从
add_to_sequence

返回到
make_insn_sequence

。在
2469
行的
last

指向，由
add_to_sequence

返回的，上图中
poistion

域是“
11
”的
decision

。

make_insn_sequence (continued)

2465

/* Find the end of
the test chain on the last node.
*/

2466

for
(test =
last->tests; test->next; test = test->next)

2467

continue
;

2468

place = &test->next;

2469

2470

/* Skip the C test
if it's known to be true at compile time.

*/

2471

if (truth == -1)

2472

{

2473

/* Need a new
node if we have another test to add.
*/

2474

if (test->type == DT_accept_op)

2475

{

2476

last = new_decision
(c_test_pos, &last->success);

2477

place = &last->tests;

2478

}

2479

test = new_decision_test
(DT_c_test, &place);

2480

test->u.c_test = c_test;

2481

}

2482

2483

test = new_decision_test
(DT_accept_insn, &place);

2484

test->u.insn.code_number = next_insn_code

;

2485

test->u.insn.lineno = pattern_lineno

;

2486

test->u.insn.num_clobbers_to_add = 0;

在
2475
行，
truth

是
2418
行的
maybe_eval_c_test

的结果。正如我们已经在
genconditions
中看到的，
maybe_eval_c_test

将返回
-1
，如果条件测试部分不是编译时常量。对于我们的例子，这个条件测试部分是：

"TARGET_64BIT && ix86_match_ccmode (insn,
CCNOmode)"

函数
ix86_match_ccmode

不是编译时的常量，因此
truth

在这里将是
-1
（参见
2475
行）。注意到在
2471
行，
place

指向最后一个
test
节点
next

域的地址，在执行了上面的代码后，我们可以得到下面的树。



图
12

：
向决策序列加入
RTL
模板，图
3

make_insn_sequence (continued)

2492

switch
(type)

2493

{

2494

case
RECOG:

2495

/* If this is a
DEFINE_INSN and X is a PARALLEL, see if it ends

2496

with a group of CLOBBERs of (hard)
registers or MATCH_SCRATCHes.

2497

If so, set up to recognize the pattern
without these CLOBBERs.
*/

2498

2499

if (GET_CODE (x) == PARALLEL)

2500

{

2501

int i;

2502

2503

/* Find the last non-clobber in the parallel.

*/

2504

for
(i = XVECLEN (x, 0); i > 0; i--)

2505

{

2506

rtx y = XVECEXP (x, 0, i - 1);

2507

if (GET_CODE
(y) != CLOBBER

2508

|| (GET_CODE (XEXP (y, 0)) != REG

2509

&& GET_CODE (XEXP (y, 0)) !=
MATCH_SCRATCH))

2510

break
;

2511

}

2512

2513

if (i != XVECLEN (x, 0))

2514

{

2515

rtx new;

2516

struct
decision_head clobber_head;

2517

2518

/* Build a
similar insn without the clobbers.
*/

2519

if (i == 1)

2520

new = XVECEXP (x, 0, 0);

2521

else

2522

{

2523

int
j;

2524

2525

new = rtx_alloc (PARALLEL);

2526

XVEC (new, 0) = rtvec_alloc (i);

2527

for
(j = i -
1; j >= 0; j--)

2528

XVECEXP (new, 0, j) = XVECEXP (x, 0,
j);

2529

}

2530

2531

/* Recognize
it.
*/

2532

memset (&clobber_head, 0, sizeof
(clobber_head));

2533

last = add_to_sequence
(new, &clobber_head, "", type, 1);

2534

2535

/* Find the end of
the test chain on the last node.
*/

2536

for
(test =
last->tests; test->next; test = test->next)

2537

continue
;

2538

2539

/* We definitely
have a new test to add -- create a new

2540

node if needed.
*/

2541

place = &test->next;

2542

if
(test->type == DT_accept_op)

2543

{

2544

last = new_decision ("",
&last->success);

2545

place
= &last->tests;

2546

}

2547

2548

/* Skip the C test
if it's known to be true at compile

2549

time.

*/

2550

if (truth == -1)

2551

{

2552

test =
new_decision_test
(DT_c_test, &place);

2553

test->u.c_test = c_test;

2554

}

2555

2556

test = new_decision_test
(DT_accept_insn, &place);

2557

test->u.insn.code_number = next_insn_code

;

2558

test->u.insn.lineno = pattern_lineno

;

2559

test->u.insn.num_clobbers_to_add = XVECLEN
(x, 0) - i;

2560

2561

merge_trees
(&head, &clobber_head);

2562

}

2563

}

2564

break
;

2565

2566

case
SPLIT:

2567

/* Define the
subroutine we will call below and emit in genemit.
*/

2568

printf ("extern rtx gen_split_%d
(rtx *);/n", next_insn_code

);

2569

break
;

2570

2571

case
PEEPHOLE2:

2572

/* Define the
subroutine we will call below and emit in genemit.
*/

2573

printf ("extern rtx gen_peephole2_%d
(rtx, rtx *);/n",

2574

next_insn_code);

2575

break
;

2576

}

2577

2578

return
head;

2579

}

对于我们的例子模式，其类型是
RECOG
，并且其编码是
SET
，因此在函数余下部分不做任何事。

回到
main

，在
make_insn_sequence

返回了这棵树的根节点后，这个根节点作为第二个参数传递给
merge_trees

。我们的例子模式是
i386.md
中的第一个
define_insn
模式，因此
recog_tree

全是
0
，并在
1407
行返回。

为了更贴近地看
merge_trees

可以为我们做什么，我们需要另一个模式。在
i386.md
里，跟着我们例子的下一个
define_insn
模式是：

497

(define_insn "*cmpdi_minus_1_rex64"

498

[(set (reg 17)

499

(compare (minus:DI (match_operand:DI
0 "nonimmediate_operand" "rm,r")

500

(match_operand:DI
1 "x86_64_general_operand" "re,mr"))

501

(const_int 0)))]

502

"TARGET_64BIT
&& ix86_match_ccmode (insn, CCGOCmode)"

503

"cmp{q}/t{%1, %0|%0, %1}"

504

[(set_attr "type" "icmp")

505

(set
_attr
"mode" "DI")])

而在
make_insn_sequence

处理之后，对于该模式我们可以得到以下的树。