9.6.3. 输出功能单元数据
在产生了为指令提取属性的函数之后，用于调度器的数据及辅助函数将被生成如下。
main (continued)
6224 if (num_units|| num_dfa_decls)
6225 {
6226 /*Write out information about function units. */
6227 write_function_unit_info ();
6228 /*Output code for pipeline hazards recognition based on DFA
6229 (deterministicfinite state automata. */
6230 write_automata ();
6231 }
至于指令之间的接口，考虑以下来自gccinfo的段落。
在现代处理器中，主要有两种连锁延迟（interlock delay）。第一种是一个数据依赖延迟（data dependence delay）确定的“指令休眠时间（instruction latency time）”。该指令的执行直到所有的源数据都被之前的指令所评估后，才开始（有更复杂的情形，即当该指令开始执行时，即便这个数据还不可用，但数据会在该指令开始执行后的给定时间内就绪）。把数据依赖延迟考虑入内是简单的。两条指令之间的数据依赖（真依赖，输出依赖，反向依赖）延迟由一个常量给定。在绝大多数情形中，这个方法就足够了。第二种连锁延迟是一个预订延迟（reservationdelay）。预订延迟意味着两条执行中的指令将需要共享的处理器资源，即，总线，内部寄存器，及/或功能单元，它们会被预订一段时间。把这种延迟考虑入内是复杂的，尤其对于现代的RISC处理器。
在处理DEFINE_FUNCTION_UNIT模式一节中，我们已经看到expand_units将构建属性来为功能单元保存信息。这些属性列出如下：
*`unit-name`_cost_`op-num` （可选，指令功能单元的issue-cost）
*function_units_used （为指令所使用的功能单元）
*`unit-name`_block_`op-num` （指令阻塞功能单元）
*`unit-name`_unit_blockage_range （可选）
*`unit-name`_ready_cost （对于指令功能单元的就绪代价）
*result_ready_cost （对于所有指令功能单元的就绪代价）
*`unit-name`_cases （为使用指令绑定binds op->condexp与op->num）
对于上面的属性，op是代表使用这个功能单元的指令。
注意除了下面指定的属性以外的属性，将被输出作为函数。生成的函数result_ready_cost描述了上面的“指令休眠时间（instruction latencytime）“，而阻塞的属性描述了预订的延迟。
其中，*`unit-name`_cost_`op-num`，*`unit-name`_block_`op-num`，*`unit-name`_cases都设置了特殊的标记（is_special）。这些属性将不会被write_attr_get所输出（参见main的6197行），而其它属性将被上面的write_attr_get所输出。这些属性所包含的信息将在这里用于产生函数。
5616 static void
5617 write_function_unit_info (void) ingenattrtab.c
5618 {
5619 struct function_unit *unit;
5620 int i;
5621
5622 /* Write outconflict routines for function units. Don't bother writing
5623 one if there is only one issue delayvalue. */
5624
5625 for (unit = units;unit; unit = unit->next)
5626 {
5627 if (unit->needs_blockage_function)
5628 write_complex_function (unit,"blockage", "block");
5629
5630 /* If the minimumand maximum conflict costs are the same, there
5631 is only one value, so we don't need afunction. */
5632 if (! unit->needs_conflict_function)
5633 {
5634 unit->default_cost = make_numeric_value (unit->issue_delay.max);
5635 continue;
5636 }
5637
5638 /* The functionfirst computes the case from the candidate insn. */
5639 unit->default_cost = make_numeric_value (0);
5640 write_complex_function (unit,"conflict_cost", "cost");
5641 }
5642
5643 /* Now that allfunctions have been written, write the table describing
5644 the function units. The name is includedfor documentation purposes
5645 only. */
5646
5647 printf ("const struct function_unit_descfunction_units[] = {\n");
5648
5649 /* Write out thedescriptions in numeric order, but don't force that order
5650 on the list. Doing so increases the runtimeof genattrtab.c. */
5651 for (i = 0; i< num_units;i++)
5652 {
5653 for (unit =units;unit; unit = unit->next)
5654 if (unit->num == i)
5655 break;
5656
5657 printf (" {\"%s\", %d, %d, %d, %s, %d,%s_unit_ready_cost, ",
5658 unit->name, 1 <<unit->num, unit->multiplicity,
5659 unit->simultaneity, XSTR(unit->default_cost, 0),
5660 unit->issue_delay.max,unit->name);
5661
5662 if (unit->needs_conflict_function)
5663 printf ("%s_unit_conflict_cost,", unit->name);
5664 else
5665 printf ("0, ");
5666
5667 printf ("%d, ",unit->max_blockage);
5668
5669 if (unit->needs_range_function)
5670 printf ("%s_unit_blockage_range,", unit->name);
5671 else
5672 printf ("0, ");
5673
5674 if (unit->needs_blockage_function)
5675 printf ("%s_unit_blockage",unit->name);
5676 else
5677 printf ("0");
5678
5679 printf ("}, \n");
5680 }
5681
5682 if (num_units == 0)
5683 printf ("{\"dummy\", 0, 0, 0,0, 0, 0, 0, 0, 0, 0} /* a dummy element */");
5684 printf ("};\n\n");
5685 }
在5628行的调用中，参数name是“blockage”，而connection是“block”，在5640行，参数name是“conflict_cost”，而connection则是“cost”。在expand_units中，可以看到当最大阻塞不等于最小阻塞时（2096 ~ 2100行），设置标记needs_blockage_function，而当最大issue_delay不等于最小issue_delay时（1849行），设置标记needs_conflict_function。不过，注意当设置了needs_conflict_function时，needs_blockage_function也要设置。
因此在write_complex_function中的5750行，对于第一次调用（在write_function_unit_info的5628行，我们为每个单元查找属性*`unit-name`_block_`op-num`（该属性与单元一一对应），而对于第二次调用（在write_function_unit_info的5640行）我们为每个单元查找属性*`unit-name`_cost_`op-num`（该属性与单元一一对应）。
5687 static void
5688 write_complex_function (struct function_unit *unit, ingenattrtab.c
5689 constchar *name,
5690 constchar *connection)
5691 {
5692 struct attr_desc*case_attr, *attr;
5693 struct attr_value*av, *common_av;
5694 rtx value;
5695 char str[256];
5696 const char*pstr;
5697 int using_case;
5698 int i;
5699
5700 printf ("static int\n");
5701 printf ("%s_unit_%s (rtx executing_insn,rtx candidate_insn)\n",
5702 unit->name, name);
5703 printf ("{\n");
5704 printf (" rtx insn;\n");
5705 printf (" int casenum;\n\n");
5706 printf (" insn = executing_insn;\n");
5707 printf (" switch (recog_memoized (insn))\n");
5708 printf (" {\n");
5709
5710 /* Write the`switch' statement to get the case value. */
5711 if (strlen (unit->name) + sizeof "*_cases" > 256)
5712 abort ();
5713 sprintf (str, "*%s_cases",unit->name);
5714 pstr = str;
5715 case_attr = find_attr(&pstr, 0);
5716 if (! case_attr)
5717 abort ();
5718 common_av = find_most_used (case_attr);
5719
5720 for (av = case_attr->first_value;av; av = av->next)
5721 if (av != common_av)
5722 write_attr_case (case_attr, av, 1,
5723 "casenum =",";", 4, unit->condexp);
5724
5725 write_attr_case (case_attr, common_av, 0,
5726 "casenum =",";", 4, unit->condexp);
5727 printf (" }\n\n");
5728
5729 /* Now write anouter switch statement on each case. Then write
5730 the tests on the executing function withineach. */
5731 printf (" insn = candidate_insn;\n");
5732 printf (" switch (casenum)\n");
5733 printf (" {\n");
5734
5735 for (i = 0; i < unit->num_opclasses; i++)
5736 {
5737 /* Ensure usingthis case. */
5738 using_case = 0;
5739 for (av =case_attr->first_value; av; av = av->next)
5740 if (av->num_insns
5741 && contained_in_p (make_numeric_value (i), av->value))
5742 using_case = 1;
5743
5744 if (! using_case)
5745 continue;
5746
5747 printf (" case %d:\n", i);
5748 sprintf (str, "*%s_%s_%d",unit->name, connection, i);
5749 pstr = str;
5750 attr = find_attr(&pstr, 0);
5751 if (! attr)
5752 abort ();
5753
5754 /* If singlevalue, just write it. */
5755 value = find_single_value (attr);
5756 if (value)
5757 write_attr_set (attr, 6, value, "return", ";\n", true_rtx,-2, -2);
5758 else
5759 {
5760 common_av = find_most_used (attr);
5761 printf (" switch (recog_memoized (insn))\n");
5762 printf ("\t{\n");
5763
5764 for (av =attr->first_value; av; av = av->next)
5765 if (av != common_av)
5766 write_attr_case (attr, av, 1,
5767 "return",";", 8, unit->condexp);
5768
5769 write_attr_case (attr, common_av, 0,
5770 "return", ";", 8,unit->condexp);
5771 printf (" }\n\n");
5772 }
5773 }
5774
5775 /* This defaultcase should not be needed, but gcc's analysis is not
5776 good enough to realize that the defaultcase is not needed for the
5777 secondswitch statement. */
5778 printf (" default:\n abort ();\n");
5779 printf (" }\n}\n\n");
5780 }
在5718行，属性*`unit-name`_cases首先被输出。对于这个属性，其内容是COND对象，以op的condexp（用于指令的匹配模式）作为测试表达式，并且在跳转中为op的序号。记住op的condexp将使用known_true，及这里的unit的condexp（该表达式表示这个单元被选中但不不知道是谁）表达式来简化。这个输出函数看起来如下（绿色的内容不是工具输出的）。
static int
`unit-name`_units_blockage (rtxexecuting_insn, rtx candidate_insn)
{
rtx insn;
int casenum;
insn = executing_insn;
switch (recog_memoized (insn))
{
case insn-code-n : //instructions that use this value
…
extract_constrain_insn_cached (insn); // used according to attr characteristic.
extract_insn_cached (insn); // used according to attr characteristic.
if (`op1->condexp` ) // simplified op->condexp for insn n
{
casenum = `op1->num`; // op number for insn n
}
else if (…) // for attribute value of cond
…
else // for attribute value of cond
…
break;
… // other & default cases, default casewritten by line 5725
}
insn = candidate_insn;
switch (casenum)
{
case 0 : // attribute of `unit-name`_block_0
switch (recog_memoized (insn))
{
case insn-code-m :
…
extract_constrain_insn_cached(insn); // used according to attr characteristic
extract_insn_cached(insn); //used according to attr characteristic.
return `op0->issue_delay`; // often it is typical case
…
}
…
}
}
`unit-name`_units_blockage，给定一个已经运行在该单元上的指令，以及一个将要运行的候选，将给出由于功能单元冲突造成的延迟。对于write_complex_function的第二次调用，我们可以得到如下生成的函数（绿色内容不是工具输出的）。
staticint
`unit-name`_units_conflict_cost (rtxexecuting_insn, rtx candidate_insn)
{
rtx insn;
int casenum;
insn = executing_insn;
switch (recog_memoized (insn))
{
caseinsn-code-n : // instructions that use this value
…
extract_constrain_insn_cached(insn); // used accordingto attr characteristic.
extract_insn_cached(insn); //used according to attr characteristic.
if(`op1->condexp` ) // simplified op->condexp for insn n
{
casenum = `op1->num`; // op number for insn n
}
else if (…) // for attribute value of cond
…
else // for attribute value of cond
…
break;
… // other & default cases, default casewritten by line 5725
}
insn= candidate_insn;
switch(casenum)
{
case 0 : // attribute of `unit-name`_block_0
switch (recog_memoized (insn))
{
caseinsn-code-m :
…
extract_constrain_insn_cached(insn); // used according to attr characteristic
extract_insn_cached(insn); //used according to attr characteristic.
if (`op0->conflict_exp`) // typical style for conflict case
return `op0->issue_delay`;
else
return 0 ;
…
}
…
}
}
`unit-name`_units_conflict_cost，给定一个已经运行在这个单元的指令，以及一个将要运行的候选，将给出从这个正在执行指令开始的时间到该候选可以开始的时间代价（忽略并发指令数目的限制）。
这两个函数组听起来很相似。阻塞与冲突代价的区别在于阻塞应用于使用该单元的指令，而冲突代价仅为被冲突列表指出的指令所承担，其它没有。
实际上，`unit-name`_units_blockage组从目的意义上，包含`unit-name`_units_conflict_cost组。在代码中，因为属性*`unit-name`_block_`op-num`及*`unit-name`_cost_`op-num`含有相同的值（参见expand_units，1856及2084行）。并且设置标记needs_conflict_function，同时还会设置needs_blockage_function（反之则不然）。
因此稍后，我们可以看到仅使用`unit-name`_units_blockage。
在write_function_unit_info余下部分里，填充function_units数组，至于function_unit的定义，参见genattr工具，由函数write_units产生。
5518
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
