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

4.2.11.      更新用于函数调用的物理寄存器信息

回到backend_init，如果源代码要进行尺寸优化或者优化级别高于–O2，flag_caller_saves将是true。那么init_caller_save被调用。在这里我们关注所有被函数调用使用的物理寄存器，并且它们没有被排除在跨函数调用外（由regclass.c中的fixed_regs，call_used_regs等所指定）。

注意到对于这个评估，它也是在由创建伪函数上下文一节中所创建的伪函数上下文中执行。

 

111     void

112     init_caller_save (void)                                                                       in caller-save.c

113     {

114       rtx addr_reg;

115       int offset;

116       rtx address;

117       int i, j;

118       enum machine_mode mode;

119       rtx savepat, restpat;

120      rtx test_reg, test_mem;

121      rtx saveinsn, restinsn;

122   

123      /* First find all the registers that we need to deal with and all

124        the modes that they can have. If we can't find a mode to use,

125        we can't have the register live over calls.  */

126   

127      for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)

128      {

129        if (call_used_regs[i] && ! call_fixed_regs[i])

130        {

131          for (j = 1; j <= MOVE_MAX_WORDS; j++)

132          {

133            regno_save_mode[i][j] = HARD_REGNO_CALLER_SAVE_MODE (i, j,

134                                                             VOIDmode);

135            if (regno_save_mode[i][j] == VOIDmode && j == 1)

136            {

137              call_fixed_regs[i] = 1;

138              SET_HARD_REG_BIT (call_fixed_reg_set, i);

139            }

140          }

141        }

142        else

143          regno_save_mode[i][1] = VOIDmode;

144    }

 

在131行，MOVE_MAX_WORDS具有定义如下。

 

47      #define MOVE_MAX_WORDS (MOVE_MAX / UNITS_PER_WORD)  in caller-save.c

 

MOVE_MAX，对于x86机器，被定义为16，它是我们在一条合理的快速指令中，能在内存间所能移动的最大字节数。

 

1137   #define HARD_REGNO_CALLER_SAVE_MODE(REGNO, NREGS, MODE)/ in i386.h

1138     (CC_REGNO_P (REGNO) ? VOIDmode                                  /

1139      : (MODE) == VOIDmode && (NREGS) != 1 ? VOIDmode                   /

1140      : (MODE) == VOIDmode ? choose_hard_reg_mode ((REGNO), (NREGS), false)/

1141      : (MODE) == HImode && !TARGET_PARTIAL_REG_STALL ? SImode             /

1142      : (MODE) == QImode && (REGNO) >= 4 && !TARGET_64BIT ? SImode        /

1143      : (MODE))

 

HARD_REGNO_CALLER_SAVE_MODE尝试找出要求NREGS个连续的从REGNO编号开始的寄存器的模式，如果没有这样的模式，将返回VOIDmode。这个结果将被保存在regno_save_mode[REGNO][NREGS]。看到127行，循环控制变量j的初始值是1，因此regno_save_mode[REGNO][0]永远不会用到，一直为VOIDmode。

根据init_reg_sets_1及表6：x86机器的寄存器分组，call_fixed_regs[REGNO]的值，如果是1，表示对应的寄存器有固定的用途，或者为函数调用机制所使用的寄存器，它不能在跨越多个调用的时段内保存数值，即便通过暂存和恢复的手段。并且回忆call_fixed_regs是call_used_regs的子集，call_used_regs还包括了调用间被破坏的寄存器，这些寄存器通过暂存和恢复的手段可以跨越调用。

在为不同数据尺寸收集了有效模式后，init_caller_save继续检查，那些我们可以不需要辅助寄存器（scratching register）或其他复杂性，而保存及恢复一个寄存器的条件。

 

init_caller_save (continue)

 

146    /* The following code tries to approximate the conditions under which

147       we can easily save and restore a register without scratch registers or

148       other complexities. It will usually work, except under conditions where

149       the validity of an insn operand is dependent on the address offset.

150       No such cases are currently known.

151   

152       We first find a typical offset from some BASE_REG_CLASS register.

153       This address is chosen by finding the first register in the class

154       and by finding the smallest power of two that is a valid offset from

155       that register in every mode we will use to save registers.  */

156   

157    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)

158       if (TEST_HARD_REG_BIT

159            (reg_class_contents

160            [(int) MODE_BASE_REG_CLASS (regno_save_mode [i][1])], i))

161         break;

162   

163    if (i == FIRST_PSEUDO_REGISTER)

164       abort ();

165   

166    addr_reg = gen_rtx_REG (Pmode, i);

167   

168    for (offset = 1 << (HOST_BITS_PER_INT / 2); offset; offset >>= 1)

169    {

170       address = gen_rtx_PLUS (Pmode, addr_reg, GEN_INT (offset));

171   

172       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)

173         if (regno_save_mode[i][1] != VOIDmode

174                && ! strict_memory_address_p (regno_save_mode[i][1], address))

175           break;

176   

177       if (i == FIRST_PSEUDO_REGISTER)

178         break;

179    }

180   

181    /* If we didn't find a valid address, we must use register indirect.  */

182    if (offset == 0)

183       address = addr_reg;

 

MODE_BASE_REG_CLASS(mode)，对于x86机器，是GENERAL_REGS，当用作reg_class_contents的索引时，将返回代表eax，ebx，ecx，edx，esi，edi，ebp，esp，r8 ~ r15的位图。因此对于157行的FOR循环，i = 0 (eax) 将退出循环。这个寄存器在166行用于保存地址，然后在170行，进一步创建如下图中的地址。

如我们在什么所见，regno_save_mode[REGNO][1] ，如果不是VOIDmode，则表示了编号为REGNO的寄存器所能支持的模式。而strict_memory_address_p则检查这个模式是否能支持地址。实际上strict_memory_address_p调用GO_IF_LEGITIMATE_ADDRESS，而这个宏则调用legitimate_address_p。

图31：地址表达式的rtx对象

浏览legitimate_address_p，已知在上图中，base指向REG，disp指向const_int，该函数将检查保存base的寄存器（eax）及disp是否有效。对于上图中所展示的地址， strict_memory_address_p将返回true。注意到在strict_memory_address_p中，在regno_save_mode[REGNO][1]中的模式在处理中没有用到，仅地址表达式被评估，因此在172行的FOR循环中，寄存器0 ~ FIRST_PSEUDO_REGISTER被成功处理。

 

init_caller_save (continue)

 

185    /* Next we try to form an insn to save and restore the register. We

186       see if such an insn is recognized and meets its constraints.

187   

188       To avoid lots of unnecessary RTL allocation, we construct all the RTL

189       once, then modify the memory and register operands in-place.  */

190   

191    test_reg = gen_rtx_REG (VOIDmode, 0);

192    test_mem = gen_rtx_MEM (VOIDmode, address);

193    savepat = gen_rtx_SET (VOIDmode, test_mem, test_reg);

194    restpat = gen_rtx_SET (VOIDmode, test_reg, test_mem);

195   

196    saveinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, 0, 0, savepat, -1, 0, 0);

197    restinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, 0, 0, restpat, -1, 0, 0);

198   

199    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)

200       for (mode = 0 ; mode < MAX_MACHINE_MODE; mode++)

201         if (HARD_REGNO_MODE_OK (i, mode))

202         {

203           int ok;

204   

205           /* Update the register number and modes of the register

206             and memory operand.  */

207           REGNO (test_reg) = i;

208           PUT_MODE (test_reg, mode);

209           PUT_MODE (test_mem, mode);

210   

211            /* Force re-recognition of the modified insns.  */

212           INSN_CODE (saveinsn) = -1;

213           INSN_CODE (restinsn) = -1;

214   

215           reg_save_code[i][mode] = recog_memoized (saveinsn);

216           reg_restore_code[i][mode] = recog_memoized (restinsn);

217   

218           /* Now extract both insns and see if we can meet their

219             constraints.  */

220           ok = (reg_save_code[i][mode] != -1

221               && reg_restore_code[i][mode] != -1);

222           if (ok)

223           {

224             extract_insn (saveinsn);

225             ok = constrain_operands (1);

226             extract_insn (restinsn);

227             ok &= constrain_operands (1);

228           }

229   

230           if (! ok)

231           {

232             reg_save_code[i][mode] = -1;

233             reg_restore_code[i][mode] = -1;

234           }

235         }

236         else

237         {

238           reg_save_code[i][mode] = -1;

239           reg_restore_code[i][mode] = -1;

240         }

241   

242    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)

243       for (j = 1; j <= MOVE_MAX_WORDS; j++)

244         if (reg_save_code [i][regno_save_mode[i][j]] == -1)

245         {

246           regno_save_mode[i][j] = VOIDmode;

247           if (j == 1)

248           {

249             call_fixed_regs[i] = 1;

250             SET_HARD_REG_BIT (call_fixed_reg_set, i);

251           }

252         }

253    }

 

接下来，只要内存地址是有效的，如果寄存器可以通过一个简单的SET后端指令（见193及194行）保存符合其最大机器模式的数据，那么该寄存器可用于调用者保存（caller-save）。我们将这些指令的INSN_CODE记录在reg_save_code[REGNO][mode]中（recog_memoized如果能识别该指令，将返回其INSN_CODE）。另外，reg_restore_code[REGNO][mode] 有可能不能被识别，因为在我们产生这些指令时，这些地址可能不是有效的。

为此，需要生成评估所用的rtx对象。 上面，在196及197行，gen_rtx_INSN创建了如下2个INSN对象。

 

 

图32：寄存器->内存，初始rtx对象

 

图33：内存->寄存器，初始rtx对象

在199行的FOR循环，遍历了所有可用的寄存器及机器模式，检查将寄存器保存入内存，及从内存恢复寄存器是否可行。从207到213行，重置了寄存器编号，机器模式，及指令码。注意到在212及213行，指令码被设置为-1，在recog_memoized中，在215及216行，这个值将触发对recog的调用。这个函数如果能识别该INSN对象，将返回指令码；否则返回-1。

如果指定的寄存器及机器模式被recog所识别，那么在224~227行通过extract_insn及 constrain_operands检查该INSN对象的有效性。接着在242行，进一步根据reg_save_code[REGNO][1]更新call_fixed_regs。

 

4.2.12.      清除伪函数上下文

在此，后端的初始化已经完成，现在需要清除伪函数上下文。

 

6861 void

6862 expand_dummy_function_end (void)                                                          in function.c

6863 {

6864   /* End any sequences that failed to be closed due to syntax errors.  */

6865   while (in_sequence_p ())

6866     end_sequence ();

6867

6868   /* Outside function body, can't compute type's actual size

6869     until next function's body starts.  */

6870  

6871     free_after_parsing (cfun);

6872     free_after_compilation (cfun);

6873     cfun = 0;

6874   }

 

这里free_after_parsing不做任何事情，而free_after_compilation将重置cfun的大部分域。