GCC后端及汇编发布（18）

9.3.4.

读入
DEFINE_DELAY
模式

DEFINE_DELAY
的细节请参考
DEFINE_DELAY模式的概览

。对于这种模式，我们使用以下例子：

278

(define_delay (and (eq_attr
"type" "branch")

in mips.md

279

(eq (symbol_ref "TARGET_MIPS16")
(const_int 0)))

280

[(eq_attr "can_delay" "yes")

281

(nil)

282

(and (eq_attr "branch_likely" "yes")

283

(eq_attr
"can_delay" "yes"))])

在经过
init_md_reader_args

的处理后，上面的模式被作为以下
rtx
对象载入内存。



图
41

：
DEFINE_DELAY
模式的例子

gen_delay

简单地把这些对象链接在一起。

4430

static
void

4431

gen_delay (rtx def,
int lineno)

in genattrtab.c

4432

{

4433

struct
delay_desc
*delay;

4434

int i;

4435

4436

if (XVECLEN (def, 1) % 3 != 0)

4437

{

4438

message_with_line (lineno,

4439

"number of elements in
DEFINE_DELAY must be multiple of three");

4440

have_error

= 1;

4441

return
;

4442

}

4443

4444

for
(i = 0; i < XVECLEN (def, 1); i += 3)

4445

{

4446

if (XVECEXP (def, 1, i + 1))

4447

have_annul_true

= 1;

4448

if (XVECEXP (def, 1, i + 2))

4449

have_annul_false

= 1;

4450

}

4451

4452

delay = oballoc (sizeof
(struct
delay_desc));

4453

delay->def = def;

4454

delay->num = ++num_delays

;

4455

delay->next = delays

;

4456

delay->lineno = lineno;

4457

delays

= delay;

4458

}

在
4433
行，
delay_desc
是一个简单结构体，它具有如下定义。

213

struct
delay_desc

in genattrtab.c

214

{

215

rtx def;
/* DEFINE_DELAY expression.

*/

216

struct
delay_desc *next;
/* Next
DEFINE_DELAY.
*/

217

int num;
/* Number of DEFINE_DELAY, starting at 1.

*/

218

int lineno;
/* Line number.
*/

219

};

9.3.5.

读入
DEFINE_FUNCTION_UNIT
模式

DEFINE_FUNCTION_UNIT模式的概览

一节描述了
DEFINE_FUNCTION_UINT
模式的细节。在于这个模式，我们使用以下的这里：

43

(define_function_unit
"k6_alux" 1 0

in k6.md

44

(and (eq_attr "cpu" "k6")

45

(eq_attr "type"
"ishift,ishift1,rotate,rotate1,alu1,negnot,cld"))

46

1 1)

比较与我们下面将要看到的模式，这个模式是旧式的指令级别的并行性描述。两者的目的都是产生流水线危险识别器。在同一个机器描述文件中，这两个形式不能共存。至于与新描述比较，这个旧式的描述的缺点，请参考
gccint
，
10.18.8.3
节。

事实上，从其定义我们可以看到，这个模式以功能单元的角度来描述系统——它告诉我们如果被占据了，这个单元将多久才能再次可用，如果输出的结果要被作为输入使用，要多久才可行，同样它也给出了将占据它的指令列表。

而对于新的形式，也就是说我们将在下面看到的
define_insn_reservation
，它从指令的角度来描述系统——它告诉我们，在指令执行过程中，在流水线的每个阶段，哪些单元将被占据（使用模式来定义之），然后多长时间后其结果可用。这无疑是个更好的形式，因为调度器的目的是尽可能多地发布指令。以指令的角度来描述系统，可用更好地服务于这个目的。

在经过
init_md_reader_args

的处理后，上面的模式被作为以下的
rtx
对象载入内存。



图
42

：
DEFINE_FUNCTION_UNIT
模式的例子

gen_unit

从这个
rtx
对象获取信息。每个
define_funciton_unit
模式应该具有唯一的名字，这个名字用作甄别器。

4466

static
void

4467

gen_unit

(rtx def, int lineno)

in genattrtab.c

4468

{

4469

struct

function_unit

*unit;

4470

struct

function_unit_op

*op;

4471

const
char
*name = XSTR (def, 0);

4472

int multiplicity = XINT
(def,
1);

4473

int simultaneity = XINT
(def,
2);

4474

rtx condexp =
XEXP

(def, 3);

4475

int ready_cost = MAX (XINT
(def, 4), 1);

4476

int issue_delay = MAX (XINT
(def, 5), 1);

4477

4478

/* See if we have
already seen this function unit. If so, check that

4479

the multiplicity and simultaneity values
are the same. If not, make

4480

a structure for this function unit.
*/

4481

for
(unit = units

;
unit; unit = unit->next)

4482

if (! strcmp (unit->name, name))

4483

{

4484

if (unit->multiplicity != multiplicity

4485

||
unit->simultaneity != simultaneity)

4486

{

4487

message_with_line (lineno,

4488

"differing specifications given for
function unit %s",

4489

unit->name);

4490

message_with_line (unit->first_lineno,
"previous definition");

4491

have_error

= 1;

4492

return
;

4493

}

4494

break
;

4495

}

4496

4497

if (unit == 0)

4498

{

4499

unit = oballoc (sizeof
(struct

function_unit

));

4500

unit->name = name;

4501

unit->multiplicity = multiplicity;

4502

unit->simultaneity = simultaneity;

4503

unit->issue_delay.min =
unit->issue_delay.max = issue_delay;

4504

unit->num = num_units

++;

4505

unit->num_opclasses = 0;

4506

unit->condexp = false_rtx

;

4507

unit->ops
= 0;

4508

unit->next = units

;

4509

unit->first_lineno = lineno;

4510

units

= unit;

4511

}

4512

else

4513

XSTR (def, 0) = unit->name;

4514

4515

/* Make a new
operation class structure entry and initialize it.
*/

4516

op = oballoc (sizeof
(struct

function_unit_op

));

4517

op->condexp = condexp;

4518

op->num = unit->num_opclasses++;

4519

op->ready
= ready_cost;

4520

op->issue_delay = issue_delay;

4521

op->next = unit->ops;

4522

op->lineno = lineno;

4523

unit->ops = op;

4524

num_unit_opclasses

++;

4525

4526

/* Set our issue
expression based on whether or not an optional conflict

4527

vector was specified.
*/

4528

if (XVEC (def, 6))

4529

{

4530

/* Compute the
IOR of all the specified expressions.

*/

4531

rtx orexp = false_rtx

;

4532

int i;

4533

4534

for
(i = 0; i < XVECLEN (def, 6); i++)

4535

orexp =
insert_right_side

(IOR, orexp, XVECEXP (def, 6, i), -2, -2);

4536

4537

op->conflict_exp = orexp;

4538

extend_range (&unit->issue_delay, 1,
issue_delay);

4539

}

4540

else

4541

{

4542

op->conflict_exp = true_rtx

;

4543

extend_range (&unit->issue_delay,
issue_delay, issue_delay);

4544

}

4545

4546

/* Merge our
conditional into that of the function unit so we can determine

4547

which insns are used by the function
unit.
*/

4548

unit->condexp =
insert_right_side

(IOR, unit->condexp, op->condexp, -2, -2);

4549

}

function_unit
的
condexp

域指向一个表达式，如果其值是
TURE
，表示需要这个单元。构建出来的
function_unit object
被保存在数组
units

里。

238

struct
function_unit

in
genattrtab.c

239

{

240

const
char *name;
/* Function unit name.
*/

241

struct
function_unit *next;
/* Next function
unit.
*/

242

int num;
/* Ordinal of this unit type.
*/

243

int multiplicity;
/* Number of units of this type.
*/

244

int simultaneity;
/* Maximum number of simultaneous insns

245

on this function unit or 0 if unlimited.
*/

246

rtx condexp;
/* Expression TRUE for insn needing unit.
*/

247

int num_opclasses;
/* Number of different operation types.
*/

248

struct

function_unit_op

*ops;
/* Pointer to first operation type.
*/

249

int needs_conflict_function;
/* Nonzero if a conflict function required.
*/

250

int needs_blockage_function;
/* Nonzero if a blockage function
required.
*/

251

int needs_range_function;
/* Nonzero if blockage range function needed.
*/

252

rtx default_cost;
/* Conflict cost, if constant.
*/

253

struct
range issue_delay;
/* Range of issue
delay values.
*/

254

int max_blockage;
/* Maximum time an insn blocks the unit.
*/

255

int first_lineno;
/* First seen line number.

*/

256

};

某些功能单元可能被多个指令组所使用（在一个
define_function_unit
里可以出现多个指令，我们称之为一组，因为如果出现，它们具有相似的发布延迟，就绪代价，及冲突列表）。因为每个组可能包含所涉及的特有的参数，这需要额外的数据结构。结构体
function_unit_op
为这个目的而设计。

223

struct
function_unit_op

in
genattrtab.c

224

{

225

rtx condexp;
/* Expression TRUE for applicable insn.
*/

226

struct
function_unit_op *next; /* Next operation for this function unit.
*/

227

int num;
/* Ordinal for this operation type in unit.
*/

228

int ready;
/* Cost until data is ready.
*/

229

int issue_delay;
/* Cost until unit can accept another insn.
*/

230

rtx conflict_exp;
/* Expression TRUE for insns incurring issue delay.
*/

231

rtx issue_exp;
/* Expression computing issue delay.
*/

232

int lineno;
/* Line number.
*/

233

};

在这里，
function_unit_op
中的
condexp

域包含了识别组的测试的
rtx
对象。这很容易理解，在
gen_unit

里处理了所有相关的
define_cpu_unit
模式后，
function_unit
的
condexp

域由
insert_right_side

通过
IOR
所有从属的
function_unit_op
的
condexp

得到。

insert_right_side

接受两个表达式，从它们来构建一个规范的
OR


表达式。这个函数具有以下定义。

2653

static
rtx

in
genattrtab.c

2654

insert_right_side

(enum
rtx_code code, rtx exp, rtx term, int insn_code,
int insn_index)

2655

{

2656

rtx newexp;

2657

2658

/* Avoid consing in
some special cases.
*/

2659

if (code == AND && term == true_rtx

)

2660

return
exp;

2661

if (code == AND && term == false_rtx

)

2662

return
false_rtx

;

2663

if (code == AND && exp == true_rtx

)

2664

return
term;

2665

if (code == AND && exp == false_rtx

)

2666

return
false_rtx

;

2667

if (code == IOR && term == true_rtx

)

2668

return
true_rtx

;

2669

if (code == IOR && term == false_rtx

)

2670

return
exp;

2671

if (code == IOR && exp == true_rtx

)

2672

return true_rtx

;

2673

if (code == IOR && exp == false_rtx

)

2674

return
term;

2675

if (attr_equal_p (exp, term))

2676

return
exp;

2677

2678

if (GET_CODE (term) == code)

2679

{

2680

exp = insert_right_side
(code, exp, XEXP
(term, 0),

2681

insn_code, insn_index);

2682

exp = insert_right_side
(code, exp, XEXP
(term, 1),

2683

insn_code, insn_index);

2684

2685

return
exp;

2686

}

2687

2688

if (GET_CODE (exp) == code)

2689

{

2690

rtx new = insert_right_side
(code, XEXP
(exp, 1),

2691

term, insn_code, insn_index);

2692

if (new !=
XEXP

(exp, 1))

2693

/* Make a copy of this expression and
call recursively.
*/

2694

newexp = attr_rtx
(code, XEXP
(exp, 0), new);

2695

else

2696

newexp = exp;

2697

}

2698

else

2699

{

2700

/* Insert the new
term.
*/

2701

newexp = attr_rtx
(code, exp, term);

2702

}

2703

2704

return
simplify_test_exp_in_temp
(newexp,
insn_code, insn_index);

2705

}

对于我们的例子，我们在
2674
行返回。在
2678
行以下的代码用于复杂的情形来简化测试。在
2678
行的代码块用于转换形如：
A AND B, B = C AND D
的表达式。在于这种情形，它将被转换为：
(A AND C) AND D
。

类似的，对于形如：
A AND B, A = C AND D
的表达式，它将被转换为
C AND (D AND B)
，其值如果“
D AND B
”等于
D
，“
A AND B
”可以被“
A
”所替代，这就是
2696
行的含义。并且如果“
D AND B
”不等于
D
，把语句分解为“
C
”，“
D AND B
”，这正是
2690
到
2696
行的目的。

在
2704
行，
simplify_test_exp_in_temp

将执行更多的简化。我们在后面来看它。

9.3.6.

读入
DEFINE_CPU_UNIT
模式

DEFINE_INSN_RESERVATION模式的概览

一节描述了
define_cpu_unit
模式的细节。对于这个模式，我们使用以下的例子：

88

(define_cpu_unit "pentium-portu,pentium-portv"
"pentium")
in pentium.md

从这个模式开始，余下的这些模式用于构建基于
DFA
的流水线危险识别器，这是更新式的，与我们之前看到的指令级别并行性描述比较而言。至于这个新式形式的好处，同样参考
gccint
，
10.18.8
.3
节。这个模式不能与
define_function_unit
共存在同一个机器描述文件中。

在经过
init_md_reader_args

的处理后，上面的模式将作为以下的
rtx
对象载入内存。



图
43

：
DEFINE_CPU_UNIT
模式的例子

Rtx
形式并不是我们所希望的，我们需要
gen_cpu_unit

来打包这些数据。

1652

void

1653

gen_cpu_unit (rtx def)
in
genattrtab.c

1654

{

1655

decl_t

decl;

1656

char **str_cpu_units;

1657

int vect_length;

1658

int i;

1659

1660

str_cpu_units = get_str_vect ((char *) XSTR
(def, 0), &vect_length, ',',

1661

FALSE);

1662

if (str_cpu_units == NULL)

1663

fatal ("invalid string `%s' in
define_cpu_unit", XSTR (def, 0));

1664

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

1665

{

1666

decl = create_node (sizeof
(struct
decl));

1667

decl->mode = dm_unit;

1668

decl->pos = 0;

1669

DECL_UNIT

(decl)->name = check_name (str_cpu_units [i], decl->pos);

1670

DECL_UNIT

(decl)->automaton_name = (char *) XSTR (def, 1);

1671

DECL_UNIT

(decl)->query_p = 0;

1672

DECL_UNIT

(decl)->min_occ_cycle_num = -1;

1673

DECL_UNIT

(decl)->in_set_p = 0;

1674

VLA_PTR_ADD
(decls

,
decl);

1675

num_dfa_decls

++;

1676

}

1677

}

所有单元的信息被保存在由
decls

指向的列表中
，
其类型如下。

907

struct
decl

in
genautomata.c

908

{

909

/* What
node in the union? */

910

enum
decl_mode mode;

911

pos_t pos;

912

union

913

{

914

struct

unit_decl

unit;

915

struct

bypass_decl

bypass;

916

struct

automaton_decl

automaton;

917

struct

excl_rel_decl

excl;

918

struct

unit_pattern_rel_decl

presence;

919

struct

unit_pattern_rel_decl

absence;

920

struct

reserv_decl

reserv;

921

struct
insn_reserv_decl
insn_reserv;

922

} decl;

923

};

196

typedef struct

decl

*decl_t
;

in
genautomata.c

Decl
是由所有类型的模式共享的类型，用于构建基于
DFA
的流水线危险识别器。对于
define_cup_unit
模式，使用了
unit_decl

域。

727

struct
unit_decl

in
genautomata.c

728

{

729

char *name;

730

/* NULL if the automaton name is absent.
*/

731

char *automaton_name;

732

/* If the following value is not zero, the cpu
unit reservation is

733

described in define_query_cpu_unit.
*/

734

char query_p;

735

736

/* The following fields are defined by
checker.
*/

737

738

/* The following field value is nonzero if the
unit is used in an

739

regexp.

*/

740

char unit_is_used;

741

742

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

743

unit.

*/

744

int unit_num;

745

/* The following field value is corresponding
declaration of

746

automaton which was given in description. If
the field value is

747

NULL then automaton in the unit declaration
was absent.
*/

748

struct

automaton_decl

*automaton_decl;

749

/* The following field value is maximal cycle
number (1, ...) on

750

which given unit occurs in insns. Zero
value means that given

751

unit is not used in insns.

*/

752

int max_occ_cycle_num;

753

/* The following field value is minimal cycle
number (0, ...) on

754

which given unit occurs in insns. -1 value
means that given

755

unit is not used in insns.

*/

756

int min_occ_cycle_num;

757

/* The following list contains units which
conflict with given

758

unit.

*/

759

unit_set_el_t

excl_list;

760

/* The following list contains patterns which
are required to

761

reservation of given unit.
*/

762

pattern_set_el_t presence_list;

763

pattern_set_el_t final_presence_list;

764

/* The following list contains patterns which
should be not present

765

i
n reservation for given unit.
*/

766

pattern_set_el_t absence_list;

767

pattern_set_el_t final_absence_list;

768

/* The following is used only when `query_p'
has nonzero value.

769

This is query number for the unit.
*/

770

int query_num;

771

/* The following is the last cycle on which
the unit was checked for

772

correct distributions of units to automata
in a regexp.
*/

773

int last_distribution_check_cycle;

774

775

/* The following fields are defined by
automaton generator.
*/

776

777

/* The following field value is number of the
automaton to which

778

given unit belongs.
*/

779

int corresponding_automaton_num;

780

/* If the following value is not zero, the cpu
unit is present in a

781

`exclusion_set' or in right part of a
`presence_set',

782

`final_presence_set', `absence_set', and

783

`final_absence_set'define_query_cpu_unit.
*/

784

char in_set_p;

785

};

在上面的
1660
行，
get_str_vec

获取由“
,
”分隔的单元名。宏
DECL_UNIT

将访问
decl
的
unit_decl

域。