GCC-3.4.6源代码学习笔记（46）

4.2.6. 准备循环优化遍

4.2.6.1. 概览

回到backend_init，下一个调用init_loop。这个函数准备那些用于循环优化中的变量。这个优化把常量表达式移出循环体，并且可选地执行强度降低（strength-reduction，期间昂贵的操作被等效但更廉价的操作所替代）及循环展开（loop unrolling）。这个循环优化找出在循环中不依循环改变的计算（循环不变量）并将它们移到循环体外。然后识别基本及普通的归纳变量（induction variable）。
基本归纳变量（BIV）是伪寄存器，它们在循环内通过增加或减少其值而设置。普通归纳变量（GIV）也是伪寄存器，其值是基本归纳变量的线性函数。BIV由basic_induction_var识别，GIV则是由general_induction_var。
一旦归纳变量被识别，在普通归纳变量上会应用强度降低优化，而在基本归纳变量上则应用归纳变量的消除。
有时在循环中，一个寄存器被设置为一个0扩展的更窄（narrower）的值，将其变为在循环前把整个寄存器设为0，而在循环中仅拷贝低位非0部分。而其中的复杂性集中在启发式地决定何时值得这样做。

4.2.6.2. 初始化

概览中已暗示了，在执行循环优化遍之前，需要收集通过寄存器取址及在寄存器间拷贝的代价。这些工作由init_loop完成。

401 void
402 init_loop (void) in loop.c
403 {
404 rtx reg = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 1);
405
406 reg_address_cost = address_cost (reg, SImode);
407
408 copy_cost = COSTS_N_INSNS (1);
409 }

从FIRST_PSEUDO_REGISTER开始，它是虚拟寄存器，没有对应的物理寄存器。虚拟寄存器在生成RTL时使用，当真实位置在RTL生成完成之前未知，虚拟寄存器用于引用栈框内的位置。例程instantiate_virtual_regs用合适的值替代这些虚拟寄存器，这些值通常是 [frame|arg|stack]_pointer_rtx加上常量。虚拟寄存器有4个。在虚拟寄存器后面的寄存器是无足轻重的。
这里使用这些无足轻重的寄存器，因为我们只是评估使用寄存器取址的代价。这个rtx对象从GC管理的内存中分配，并且在从该函数退出后被回收。

889 int
890 address_cost (rtx x, enum machine_mode mode) in cse.c
891 {
892 /* The address_cost target hook does not deal with ADDRESSOF nodes. But,
893 during CSE, such nodes are present. Using an ADDRESSOF node which
894 refers to the address of a REG is a good thing because we can then
895 turn (MEM (ADDRESSSOF (REG))) into just plain REG. */
896
897 if (GET_CODE (x) == ADDRESSOF && REG_P (XEXP ((x), 0)))
898 return -1;
899
900 /* We may be asked for cost of various unusual addresses, such as operands
901 of push instruction. It is not worthwhile to complicate writing
902 of the target hook by such cases. */
903
904 if (!memory_address_p (mode, x))
905 return 1000;
906
907 return (*targetm.address_cost) (x);
908 }

在address_cost中的897行，REG_P检查rtx对象是否表示寄存器。符合该行条件的x代表了寄存器的地址。

272 #define REG_P(X) (GET_CODE (X) == REG) in rtl.h

对于不代表寄存器地址的x对象，不满足897行的条件。因此执行memory_address_p来评估寄存器或内存的取址代价。它返回1如果addr，对于mode模式，是一个有效的地址。

1303 int in recog.c
1304 memory_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx addr)
1305 {
1306 if (GET_CODE (addr) == ADDRESSOF)
1307 return 1;
1308
1309 GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
1310 return 0;
1311
1312 win:
1313 return 1;
1314 }

寄存器及内存的取址，显然是与目标平台相关的。同样在1306行，如果addr代表了寄存器的地址，毫无疑问，这是有效的地址。否则对于x86机器，上面的1309行有如下的定义。

2019 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) / in i386.h
2020 do { /
2021 if (legitimate_address_p ((MODE), (X), 0)) /
2022 goto ADDR; /
2023 } while (0)

6033 int
6034 legitimate_address_p (enum machine_mode mode, rtx addr, int strict) in i386.c
6035 {
6036 struct ix86_address parts;
6037 rtx base, index, disp;
6038 HOST_WIDE_INT scale;
6039 const char *reason = NULL;
6040 rtx reason_rtx = NULL_RTX;
6041
6042 if (TARGET_DEBUG_ADDR)
6043 {
6044 fprintf (stderr,
6045 "/n======/nGO_IF_LEGITIMATE_ADDRESS, mode = %s, strict = %d/n",
6046 GET_MODE_NAME (mode), strict);
6047 debug_rtx (addr);
6048 }
6049
6050 if (ix86_decompose_address (addr, &parts) <= 0)
6051 {
6052 reason = "decomposition failed";
6053 goto report_error;
6054 }

结构体ix86_address包含了，在x86机器中，对于循环控制变量的所有取址方法的各个部分。已知地址可以通过表达式来计算：base + scale*index + disp，对于在线程局部储存（TLS）中的对象，寄存器FS或GS被用作段选择器，它们为下面849行的seg所描述。

845 struct ix86_address in i386.c
846 {
847 rtx base, index, disp;
848 HOST_WIDE_INT scale;
849 enum ix86_address_seg { SEG_DEFAULT, SEG_FS, SEG_GS } seg;
850 };

而ix86_decompose_address将依据上面的表达式分解给定的地址并填充对应的ix86_address对象。

5566 static int
5567 ix86_decompose_address (rtx addr, struct ix86_address *out) in i386.c
5568 {
5569 rtx base = NULL_RTX;
5570 rtx index = NULL_RTX;
5571 rtx disp = NULL_RTX;
5572 HOST_WIDE_INT scale = 1;
5573 rtx scale_rtx = NULL_RTX;
5574 int retval = 1;
5575 enum ix86_address_seg seg = SEG_DEFAULT;
5576
5577 if (GET_CODE (addr) == REG || GET_CODE (addr) == SUBREG)
5578 base = addr;
5579 else if …

上面看到，在现在的场景下，rtx表达式addr的rtx码是REG，因此5579行以下的代码被跳过。对于寄存器，其地址的基址，无疑就是这个寄存器的地址。在该点上，我们有： scale_rtx = null，index = null，disp = null，scale = 1。

ix86_decompose_address (continue)

5706 out->base = base;
5707 out->index = index;
5708 out->disp = disp;
5709 out->scale = scale;
5710 out->seg = seg;
5711
5712 return retval;
5713 }

从ix86_decompose_address返回，parts包含如下数据： parts.base = addr，rts.index = NULL_RTX，parts.disp = NULL_RTX，parts.scale = 1，parts.seg = SEG_DEFAULT。

legitimate_address_p (continue)

6056 base = parts.base;
6057 index = parts.index;
6058 disp = parts.disp;
6059 scale = parts.scale;
6060
6061 /* Validate base register.
6062
6063 Don't allow SUBREG's here, it can lead to spill failures when the base
6064 is one word out of a two word structure, which is represented internally
6065 as a DImode int. */
6066
6067 if (base)
6068 {
6069 reason_rtx = base;
6070
6071 if (GET_CODE (base) != REG)
6072 {
6073 reason = "base is not a register";
6074 goto report_error;
6075 }
6076
6077 if (GET_MODE (base) != Pmode)
6078 {
6079 reason = "base is not in Pmode";
6080 goto report_error;
6081 }
6082
6083 if ((strict && ! REG_OK_FOR_BASE_STRICT_P (base))
6084 || (! strict && ! REG_OK_FOR_BASE_NONSTRICT_P (base)))
6085 {
6086 reason = "base is not valid";
6087 goto report_error;
6088 }
6089 }
…
6232 /* Everything looks valid. */
6233 if (TARGET_DEBUG_ADDR)
6234 fprintf (stderr, "Success./n");
6235 return TRUE;
...
6244 }

上面的base指向word模式的REG的rtx表达式 —— 在所有支持的机器上这个模式是Pmode的别名。当调用legitimate_address_p时，这里传入参数strict为0，因此在6084行，验证base的寄存器类别，作为基地址，是合适的。

1970 #define REG_OK_FOR_BASE_NONSTRICT_P(X) / in i386.h
1971 (REGNO (X) <= STACK_POINTER_REGNUM /
1972 || REGNO (X) == ARG_POINTER_REGNUM /
1973 || REGNO (X) == FRAME_POINTER_REGNUM /
1974 || (REGNO (X) >= FIRST_REX_INT_REG /
1975 && REGNO (X) <= LAST_REX_INT_REG) /
1976 || REGNO (X) >= FIRST_PSEUDO_REGISTER)

对于这个不严格的版本，arg指针寄存器和frame指针寄存器用作base是允许的（在严格版本中，这是禁止的，而在x86机器上，这2种寄存器不存在，将使用栈来代替）。
因为legitimate_address_p返回true，memory_address_p返回1至address_cost，特定于目标机器的address_cost将被调用。对于x86机器，毫无疑问，它是ix86_address_cost。在x86机器上，复杂地址更受欢迎，它可以让GCC将简单地址合成起来，从而更有效率。因此在5730 ~ 5733行，对这样的情况给予了优待。同样的保存在伪寄存器中的部分将受到惩罚，因为它们会导致效率降低。而对于这里我们的情况，代价将是1。

5720 static int
5721 ix86_address_cost (rtx x) in i386.c
5722 {
5723 struct ix86_address parts;
5724 int cost = 1;
5725
5726 if (!ix86_decompose_address (x, &parts))
5727 abort ();
5728
5729 /* More complex memory references are better. */
5730 if (parts.disp && parts.disp != const0_rtx)
5731 cost--;
5732 if (parts.seg != SEG_DEFAULT)
5733 cost--;
5734
5735 /* Attempt to minimize number of registers in the address. */
5736 if ((parts.base
5737 && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER))
5738 || (parts.index
5739 && (!REG_P (parts.index)
5740 || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)))
5741 cost++;
5742
5743 if (parts.base
5744 && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER)
5745 && parts.index
5746 && (!REG_P (parts.index) || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)
5747 && parts.base != parts.index)
5748 cost++;
5749
5750 /* AMD-K6 don't like addresses with ModR/M set to 00_xxx_100b,
5751 since it's predecode logic can't detect the length of instructions
5752 and it degenerates to vector decoded. Increase cost of such
5753 addresses here. The penalty is minimally 2 cycles. It may be worthwhile
5754 to split such addresses or even refuse such addresses at all.
5755
5756 Following addressing modes are affected:
5757 [base+scale*index]
5758 [scale*index+disp]
5759 [base+index]
5760
5761 The first and last case may be avoidable by explicitly coding the zero in
5762 memory address, but I don't have AMD-K6 machine handy to check this
5763 theory. */
5764
5765 if (TARGET_K6
5766 && ((!parts.disp && parts.base && parts.index && parts.scale != 1)
5767 || (parts.disp && !parts.base && parts.index && parts.scale != 1)
5768 || (!parts.disp && parts.base && parts.index && parts.scale == 1)))
5769 cost += 10;
5770
5771 return cost;
5772 }

回到init_loop，reg_address_cost得到值1。那么我们需要确定copy_cost的值。它由COSTS_N_INSNS给出。对于非ARM系统，COSTS_N_INSNS被定义为如下，它表明其代价等同于快速寄存器-寄存器的指令的N倍。

1995 #define COSTS_N_INSNS(N) ((N) * 4) in rtl.h