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

5.13.2.      输出 PCH 文件

看过了转换相关的内容后，回到我们例子的解析后的阶段，从 expand_or_defer_fn 返回，我们回到 cp_parser_function_definition_after_declarator ，并立即返回 FUNCTION_DECL ，这个 FUNCTION_DECL 为 cp_parser_function_definition_from_specifiers_and_declarator 返回，然后 cp_parser_init_declarator ， cp_parser_simple_declaration ， cp_parser_block_declaration ， cp_parser_declaration ，然后在 cp_parser_declaration_seq_opt 中 EOF 突破了 6224 行的 WHILE 循环，最后我们回到了解析器的入口—— cp_parser_translation_unit 。在这个函数中， EOF 在 2336 行被“消化”了，接着 finish_translation_unit 恢复全局名字空间的绑定域。

从 cp_parser_translation_unit 返回，现在我们回到 c_parser_file 。退出它，我们就回到 c_common_parse_file ——对于 C++ ，它被 lang_hooks 的 parse_file 所指向。并且看到 c_parser_file 是在一个 WHILE 循环里；如果在这个命令行中还有其他源文件，上面所看到的过程将再次重复。这意味如果我们使用形如：“ g++ -o all a.cc b.cc c.cc; ”的命令行，编译器将解析这 3 个源文件，并把结果合并到单个中间语言树。在所有的源文件被解析后，就来到 finish_file 。

来的此处，我们一定在全局名字空间中。 2540 行的检查保证了这一点。

 

2527   void

2528   finish_file (void)                                                                                      in decl2.c

2529   {

2530     tree vars;

2531     bool reconsider;

2532     size_t i;

2533     location_t locus;

2534     unsigned ssdf_count = 0;

2535  

2536     locus = input_location ;

2537     at_eof = 1;

2538  

2539     /* Bad parse errors. Just forget about it.  */

2540     if (! global_bindings_p () || current_class_type || decl_namespace_list )

2541       return ;

2542  

2543     if (pch_file )

2544       c_common_write_pch ();

 

下面， cpp_write_pch_deps 把定义在命令行所指定的源文件中的标识符写入由 pch_outfile 指定的 PCH 文件里。而 asm_file_startpos ，在读入第一个源文件时，在 pch_init 中被设置成指向 asm_out_file 的末尾；而在 c_common_parse_file 的 1242 行的 cpp_read_main_file 中， asm_out_file 被填入被包含的 PCH 文件的内容，并且在 177 行 asm_file_end 指向该文件的末尾。因此在 178 行， h.asm_size 将是被包含的 PCH 文件的内容的大小。这些内容将被增加入这个 PCH 文件。

 

165    void

166    c_common_write_pch (void)                                                                    in c-pch.c

167    {

168      char *buf;

169      long asm_file_end;

170      long written;

171      struct c_pch_header h;

172   

173      (*debug_hooks ->handle_pch) (1);

174   

175      cpp_write_pch_deps (parse_in , pch_outfile );

176   

177      asm_file_end = ftell (asm_out_file );

178      h.asm_size = asm_file_end - asm_file_startpos ;

179     

180      if (fwrite (&h, sizeof (h), 1, pch_outfile ) != 1)

181        fatal_error ("can't write %s: %m", pch_file );

182     

183      buf = xmalloc (16384);

184      fflush (asm_out_file );

185   

186      if (fseek (asm_out_file , asm_file_startpos , SEEK_SET) != 0)

187        fatal_error ("can't seek in %s: %m", asm_file_name );

188   

189      for (written = asm_file_startpos ; written < asm_file_end; )

190      {

191        long size = asm_file_end - written;

192        if (size > 16384)

193          size = 16384;

194        if (fread (buf, size, 1, asm_out_file ) != 1)

195          fatal_error ("can't read %s: %m", asm_file_name );

196        if (fwrite (buf, size, 1, pch_outfile ) != 1)

197          fatal_error ("can't write %s: %m", pch_file );

198        written += size;

199      }

200      free (buf);

201      /* asm_out_file can be written afterwards, so must be flushed first.  */

202      fflush (asm_out_file );

203   

204      gt_pch_save (pch_outfile );

205      cpp_write_pch_state (parse_in , pch_outfile );

206   

207      if (fseek (pch_outfile , 0, SEEK_SET) != 0

208         || fwrite (get_ident (), IDENT_LENGTH, 1, pch_outfile ) != 1)

209        fatal_error ("can't write %s: %m", pch_file );

210   

211       fclose (pch_outfile );

212    }

 

在上面的 175 行， pch_outfile 是为 pch_file 打开的文件句柄，它也是在 cpp_save_state 中写入使用的文件句柄。现在 r->savedstate 包含了在解析命令行指定源文件前，所出现的标识符。

 

299    int

300    cpp_write_pch_deps (cpp_reader *r, FILE *f)                                            in cpppch.c

301    {

302      struct macrodef_struct z;

303      struct cpp_savedstate *const ss = r->savedstate;

304      unsigned char *definedstrs;

305      size_t i;

306     

307      /* Collect the list of identifiers which have been seen and

308        weren't defined to anything previously.  */

309      ss->hashsize = 0;

310      ss->n_defs = 0;

311       cpp_forall_identifiers (r, count_defs , ss);

312   

313      ss->defs = xmalloc (ss->n_defs * sizeof (cpp_hashnode *));

314      ss->n_defs = 0;

315      cpp_forall_identifiers (r, write_defs , ss);

316   

317      /* Sort the list, copy it into a buffer, and write it out.  */

318      qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);

319      definedstrs = ss->definedstrs = xmalloc (ss->hashsize);

320      for (i = 0; i < ss->n_defs; ++i)

321      {

322        size_t len = NODE_LEN (ss->defs[i]);

323        memcpy (definedstrs, NODE_NAME (ss->defs[i]), len + 1);

324        definedstrs += len + 1;

325      }

326   

327      memset (&z, 0, sizeof (z));

328      z.definition_length = ss->hashsize;

329      if (fwrite (&z, sizeof (z), 1, f) != 1

330          || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1)

331      {

332        cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");

333        return -1;

334      }

335      free (ss->definedstrs);

336   

337      /* Free the saved state.  */

338      free (ss);

339      r->savedstate = NULL;

340      return 0;

341    }

 

在解析了所有在命令行中指定的源文件后， cpp_reader 在其 hash_table 中包含了在这些文件中声明的标识符。那么函数 count_defs 遍历 hash_table 来计算还需要加入多少标识符，并通过域 hashsize 计算保存名字缓存的大小。注意到在中 cpp_save_state 调用的 save_idents 里 NT_VOID 类型的节点被忽略；但这里没有。

 

209    static int

210    count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)

211     {

212      struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;

213     

214      switch (hn->type)

215      {

216        case NT_MACRO:

217          if (hn->flags & NODE_BUILTIN)

218            return 1;

219         

220          /* else fall through.  */

221   

222        case NT_VOID:

223        {

224          struct cpp_string news;

225          void **slot;

226        

227          news.len = NODE_LEN (hn);

228          news.text = NODE_NAME (hn);

229          slot = htab_find (ss->definedhash, &news);

230          if (slot == NULL)

231          {

232            ss->hashsize += NODE_LEN (hn) + 1;

233            ss->n_defs += 1;

234          }

235        }

236        return 1;

237   

238        case NT_ASSERTION:

239           /* Not currently implemented.  */

240          return 1;

241   

242        default :

243          abort ();

244      }

245    }

 

在分配了所需的资源后， write_defs 也遍历 cpp_reader 的 hash_table 来援引没有在 cpp_save_state 中出现的标识符。那么在上面 318 行的排序后，这些名字被写入这个 PCH 文件。

 

248    static int

249    write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)

250    {

251      struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;

252     

253      switch (hn->type)

254      {

255        case NT_MACRO:

256          if (hn->flags & NODE_BUILTIN)

257            return 1;

258         

259           /* else fall through.  */

260   

261        case NT_VOID:

262        {

263          struct cpp_string news;

264          void **slot;

265        

266          news.len = NODE_LEN (hn);

267          news.text = NODE_NAME (hn);

268          slot = htab_find (ss->definedhash, &news);

269          if (slot == NULL)

270          {

271            ss->defs[ss->n_defs] = hn;

272            ss->n_defs += 1;

273          }

274        }

275        return 1;

276   

277        case NT_ASSERTION:

278          /* Not currently implemented.  */

279          return 1;

280   

281        default :

282          abort ();

283      }

284    }

 

在调用 gt_pch_save 的这一点上， PCH 文件的内容如下图所示。看到 idn 就是用户在源文件中声明的标识符。

另外在编译过程中，编译器还产生许多控制数据，我们已经看到它们由 GC 管理。这些数据描述了程序的特性，并影响代码的生成，因此必须也保存在这个 PCH 文件里。

 

423    void

424    gt_pch_save (FILE *f)                                                                             in ggc-common.c

425    {

426      const struct ggc_root_tab *const *rt;

427      const struct ggc_root_tab *rti;

428      size_t i;

429      struct traversal_state state;

430      char *this_object = NULL;

431      size_t this_object_size = 0;

432      struct mmap_info mmi;

433      size_t page_size = getpagesize();

434   

435      gt_pch_save_stringpool ();

 

那么 gt_pch_save_stringpool 保存了 ident_hash 的内容，记得 ident_hash 为 cpp_reader 的 hash_table 所指向。首先，这些内容被拷贝入 spd 数据结构。

 

232    void

233    gt_pch_save_stringpool (void)                                                           in stringpool.c

234    {

235      unsigned int i;

236   

237      spd = ggc_alloc (sizeof (*spd ));

238      spd ->nslots = ident_hash ->nslots;

239      spd ->nelements = ident_hash ->nelements;

240      spd ->entries = ggc_alloc (sizeof (tree *) * spd ->nslots);

241      for (i = 0; i < spd ->nslots; i++)

242        if (ident_hash ->entries[i] != NULL)

243          spd->entries[i] = HT_IDENT_TO_GCC_IDENT (ident_hash ->entries[i]);

244        else

245          spd->entries[i] = NULL;

246   

247      saved_ident_hash = ht_create (14);

248      saved_ident_hash ->alloc_node = alloc_node;

249      ht_forall (ident_hash , ht_copy_and_clear , saved_ident_hash );

250    }

 

为了缓存 ident_hash 的内容， spd 具有如下的结构。看到 spd 在 gt_ggc_r_gt_stringpool_h 中，它进而包含在 gt_ggc_rtab 中。后面它也将被写入这个 PCH 文件，而通过 gt_pch_restore_stringpool ，被使用这个 PCH 文件的文件读入。

 

199    struct string_pool_data GTY(())                                                         in stringpool.c

200    {

201      tree * GTY((length ("%h.nslots"))) entries;

202      unsigned int nslots;

203      unsigned int nelements;

204    };

205

206     static GTY(()) struct string_pool_data * spd;

 

其次，通过下面的函数把 ident_hash 的内容移入 saved_ident_hash （把它缓存起来，以免对下面的过程产生影响，在退出 gt_pch_save 前会恢复其内容）。

 

208    static int

209    ht_copy_and_clear (cpp_reader *r ATTRIBUTE_UNUSED, hashnode hp, const void *ht2_p)

210    {

211       cpp_hashnode *h = CPP_HASHNODE (hp);

212      struct ht *ht2 = (struct ht *) ht2_p;

213   

214      if (h->type != NT_VOID

215          && (h->flags & NODE_BUILTIN) == 0)

216      {

217        cpp_hashnode *h2 = CPP_HASHNODE (ht_lookup (ht2,

218                                          NODE_NAME (h),

219                                          NODE_LEN (h),

220                                          HT_ALLOC));

221        h2->type = h->type;

222        memcpy (&h2->value, &h->value, sizeof (h->value));

223   

224        h->type = NT_VOID;

225        memset (&h->value, 0, sizeof (h->value));

226      }

227      return 1;

228    }

 

记得在编译器中，所有 GC 管理的对象都由 GC 工具处理来产生 gtype-* 文件。而在 gtype-c.h 中，生成了几个全局数组来保存对这些对象的引用。它们是 gt_ggc_rtab ， gt_ggc_deletable_rtab （保存了被删除对象的哈希表）， gt_ggc_cache_rtab （用于垃圾收集的目的）， gt_pch_cache_rtab （与 gt_ggc_cache_rtab 的内容相同，但处理方法不一样—）， gt_pch_scalar_rtab 。

 

gt_pch_save (continue)

 

437      saving_htab = htab_create (50000, saving_htab_hash, saving_htab_eq, free);

438   

439      for (rt = gt_ggc_rtab ; *rt; rt++)

440        for (rti = *rt; rti->base != NULL; rti++)

441          for (i = 0; i < rti->nelt; i++)

442            (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));

443   

444      for (rt = gt_pch_cache_rtab ; *rt; rt++)

445        for (rti = *rt; rti->base != NULL; rti++)

446          for (i = 0; i < rti->nelt; i++)

447            (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));

448   

449      /* Prepare the objects for writing, determine addresses and such.  */

450      state.f = f;

451      state.d = init_ggc_pch();

452      state.count = 0;

453      htab_traverse (saving_htab , call_count , &state);

 

PCH 文件中的内容是中间形式的代码（也就是树节点的形式），我们已经看到这个中间形式中包含了大量的指针，如何在 PCH 文件中维护这些指针，使得在 PCH 文件的使用中能恢复这里的对象之间的关系？

首先，由 GC 管理的对象都是全局对象，而且它们构成了一个封闭的集合（也就是不会有对集合外对象的引用，也不会被集合外的对象所引用）。那么如果把这些对象的内容及地址一字不差地记录入 PCH 文件，然后读入时一个个恢复这些对象，理论上就能恢复 PCH 文件的内容。但事实上不可行，因为读入 PCH 文件时，内存中很可能已经有其他内容，很难保证需要的地址一定可用，而且一个个恢复对象效率也不高。

既然 GC 管理的是由全局对象构成的封闭集合，那么在目标系统所提供的内存管理机制的协助下，存在这种可能：把所有的对象尽可能紧凑地排列起来，并为以后的 PCH 读入选定一个不太可能被占用的起始地址（对于使用虚拟内存的系统，不占用的可能性很大），同时把对象内部的所有指针都更新为相应对象的新的地址（假定起始地址可用）；最后把这个映射信息、更新后的对象内容写入 PCH 文件，就能保证后面对这个 PCH 文件的正确读入。这就是 GCC 现在的做法。

那么第一步就要收集对象中所有的指针的内容（包括对象自己的地址），这由 pchw 域引用的函数来完成，它把这些内容存入 saving_htab 。以 gt_ggc_rtab 中 gt_ggc_r_gtype_desc_c 的 cgraph_nodes_queue 为例，其 pchw 指向 gt_pch_nx_cgraph_node ，这个函数也是由 GC 工具产生。

 

1306   void

1307   gt_pch_nx_cgraph_node (void *x_p)                                                 in gtype-desc.c

1308   {

1309     struct cgraph_node * x = (struct cgraph_node *)x_p;

1310     struct cgraph_node * xlimit = x;

1311     while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_11cgraph_node ))

1312      xlimit = ((*xlimit).next);

1313     if (x != xlimit)

1314       for (;;)

1315       {

1316         struct cgraph_node * const xprev = ((*x).previous);

1317         if (xprev == NULL) break ;

1318         x = xprev;

1319         (void) gt_pch_note_object (xprev, xprev, gt_pch_p_11cgraph_node );

1320       }

1321     while (x != xlimit)

1322     {

1323       gt_pch_n_9tree_node ((*x).decl);

1324       gt_pch_n_11cgraph_edge ((*x).callees);

1325       gt_pch_n_11cgraph_edge ((*x).callers);

1326       gt_pch_n_11cgraph_node ((*x).next);

1327       gt_pch_n_11cgraph_node ((*x).previous);

1328       gt_pch_n_11cgraph_node ((*x).origin);

1329       gt_pch_n_11cgraph_node ((*x).nested);

1330       gt_pch_n_11cgraph_node ((*x).next_nested);

1331       gt_pch_n_11cgraph_node ((*x).next_needed);

1332       x = ((*x).next);

1333     }

1334   }

 

这里关键的函数是 gt_pch_note_object ，上面的函数 gt_pch_n_* 也调用 gt_pch_note_object 来缓存它们所处理的节点。

 

251    int

252    gt_pch_note_object (void *obj, void *note_ptr_cookie,                        in ggc-common.c

253                     gt_note_pointers note_ptr_fn)

254    {

255      struct ptr_data **slot;

256   

257      if (obj == NULL || obj == (void *) 1)

258        return 0;

259   

260      slot = (struct ptr_data **)

261        htab_find_slot_with_hash (saving_htab , obj, POINTER_HASH (obj),

262                              INSERT);

263      if (*slot != NULL)

264      {

265        if ((*slot)->note_ptr_fn != note_ptr_fn

266           || (*slot)->note_ptr_cookie != note_ptr_cookie)

267          abort ();

268        return 0;

269      }

270   

271      *slot = xcalloc (sizeof (struct ptr_data), 1);

272      (*slot)->obj = obj;

273      (*slot)->note_ptr_fn = note_ptr_fn;

274      (*slot)->note_ptr_cookie = note_ptr_cookie;

275      if (note_ptr_fn == gt_pch_p_S)

276        (*slot)->size = strlen (obj) + 1;

277      else

278        (*slot)->size = ggc_get_size (obj);

279      return 1;

280    }

 

saving_htab 的内容具有下面的类型 ptr_data 。结构中的域 obj 保存了被缓存对象的地址。

 

237    struct ptr_data                                                                                   in ggc-common.c

238    {

239      void *obj;

240      void *note_ptr_cookie;

241      gt_note_pointers note_ptr_fn;

242      gt_handle_reorder reorder_fn;

243      size_t size;

244      void *new_addr;

245    };

 

那么在 453 行， htab_traverse 遍历 saving_htab 并为其中的每个节点调用 call_count 。看到 state 的 count 域记录了所遭遇的对象的个数。

 

328    static int

329    call_count (void **slot, void *state_p)                                                in ggc-common.c

330    {

331      struct ptr_data *d = (struct ptr_data *)*slot;

332      struct traversal_state *state = (struct traversal_state *)state_p;

333   

334      ggc_pch_count_object (state->d, d->obj, d->size, d->note_ptr_fn == gt_pch_p_S);

335      state->count++;

336      return 1;

337    }

 

在以 Linux 为目标平台时， ggc-page.c 将被选中提供内存管理。定义在这个文件中的函数 ggc_pch_count_object 协助统计具有指定大小的对象的数目；下面的 order 表示以 2 为底 order 为指数的大小（它将是页面管理机制下所分配的内存大小）。

 

1941   void

1942   ggc_pch_count_object (struct ggc_pch_data *d, void *x ATTRIBUTE_UNUSED,

1943                       size_t size, bool is_string ATTRIBUTE_UNUSED)

1944   {

1945     unsigned order;

1946  

1947     if (size <= 256)

1948       order = size_lookup [size];

1949     else

1950     {

1951       order = 9;

1952       while (size > OBJECT_SIZE (order))

1953         order++;

1954     }

1955  

1956     d->d.totals[order]++;

1957   }

 

下面将选定新的起始地址，它将为读入过程所使用。

 

gt_pch_save (continue)

 

455      mmi.size = ggc_pch_total_size (state.d);

456   

457      /* Try to arrange things so that no relocation is necessary, but

458        don't try very hard. On most platforms, this will always work,

459        and on the rest it's a lot of work to do better. 

460        (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and

461        HOST_HOOKS_GT_PCH_USE_ADDRESS.)  */

462      mmi.preferred_base = host_hooks .gt_pch_get_address (mmi.size, fileno (f));

463         

464      ggc_pch_this_base (state.d, mmi.preferred_base);

465   

466      state.ptrs = xmalloc (state.count * sizeof (*state.ptrs));

467      state.ptrs_i = 0;

468      htab_traverse (saving_htab , call_alloc , &state);

469      qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);

470   

471      /* Write out all the scalar variables.  */

472      for (rt = gt_pch_scalar_rtab ; *rt; rt++)

473        for (rti = *rt; rti->base != NULL; rti++)

474          if (fwrite (rti->base, rti->stride, 1, f) != 1)

475            fatal_error ("can't write PCH file: %m");

 

首先需要知道所需要的整个内存的大小。这个尺寸被取整到最近的页边界。

 

1959   size_t

1960   ggc_pch_total_size (struct ggc_pch_data *d)                                             in ggc-page.c

1961   {

1962     size_t a = 0;

1963     unsigned i;

1964  

1965     for (i = 0; i < NUM_ORDERS; i++)

1966       a += ROUND_UP (d->d.totals[i] * OBJECT_SIZE (i), G .pagesize);

1967     return a;

1968   }

 

另外对象被按尺寸已升序处理，所有具有相同分配大小的对象将被放在一起；下面结构的 base 域给出这些对象的起始地址。

 

1925   struct ggc_pch_data                                                                                  in ggc-page.c

1926   {

1927     struct ggc_pch_ondisk

1928     {

1929       unsigned totals[NUM_ORDERS];

1930     } d;

1931     size_t base[NUM_ORDERS];

1932     size_t written[NUM_ORDERS];

1933   };

 

在分页机制中，所有的基址都应该被取整到页边界。看到每个不同大小的对象组都有自己的基址。

 

1970   void

1971   ggc_pch_this_base (struct ggc_pch_data *d, void *base)                                   in ggc-page.c

1972   {

1973     size_t a = (size_t) base;

1974     unsigned i;

1975  

1976     for (i = 0; i < NUM_ORDERS; i++)

1977     {

1978       d->base[i] = a;

1979       a += ROUND_UP (d->d.totals[i] * OBJECT_SIZE (i), G .pagesize);

1980     }

1981   }

 

以上面的信息，尤其是对象的基址，在 saving_htab 中被缓存的对象由 call_alloc 来重新安排。注意参数 slot 就是来自 saving_htab 的对象。

 

339    static int

340    call_alloc (void **slot, void *state_p)                                                 in ggc-common.c

341    {

342      struct ptr_data *d = (struct ptr_data *)*slot;

343      struct traversal_state *state = (struct traversal_state *)state_p;

344   

345      d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size, d->note_ptr_fn == gt_pch_p_S);

346      state->ptrs[state->ptrs_i++] = d;

347      return 1;

348    }

 

在 345 行， new_addr 保存了重新安排后对象的地址，而在下面的函数中， d 的 base 域指向下一个对象可用的地址，它是内存分配的应该彩排，没有真正分配内存。

 

1984   char *

1985   ggc_pch_alloc_object (struct ggc_pch_data *d, void *x ATTRIBUTE_UNUSED,  in ggc-page.c

1986                      size_t size, bool is_string ATTRIBUTE_UNUSED)

1987   {

1988     unsigned order;

1989     char *result;

1990  

1991     if (size <= 256)

1992        order = size_lookup [size];

1993     else

1994     {

1995       order = 9;

1996       while (size > OBJECT_SIZE (order))

1997         order++;

1998     }

1999  

2000     result = (char *) d->base[order];

2001     d->base[order] += OBJECT_SIZE (order);

2002     return result;

2003   }

 

现在在下面的 state 里，其 ptrs 数组指向对象，并且对于每个实体， new_addr 域记录了指定对象的重新映射的地址。

 

gt_pch_save (continue)

 

477      /* Write out all the global pointers, after translation.  */

478      write_pch_globals (gt_ggc_rtab , &state);

479      write_pch_globals (gt_pch_cache_rtab , &state);

 

看到 write_pch_globals 把这些对象的新地址写入 PCH 文件。

 

381    static void

382    write_pch_globals (const struct ggc_root_tab * const *tab,                  in ggc-common.c

383                    struct traversal_state *state)

384    {

385      const struct ggc_root_tab *const *rt;

386      const struct ggc_root_tab *rti;

387      size_t i;

388   

389      for (rt = tab; *rt; rt++)

390        for (rti = *rt; rti->base != NULL; rti++)

391          for (i = 0; i < rti->nelt; i++)

392           {

393            void *ptr = *(void **)((char *)rti->base + rti->stride * i);

394            struct ptr_data *new_ptr;

395            if (ptr == NULL || ptr == (void *)1)

396            {

397              if (fwrite (&ptr, sizeof (void *), 1, state->f)

398                   != 1)

399                fatal_error ("can't write PCH file: %m");

400            }

401            else

402            {

403              new_ptr = htab_find_with_hash (saving_htab , ptr,

404                                         POINTER_HASH (ptr));

405              if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f)

406                    != 1)

407                fatal_error ("can't write PCH file: %m");

408            }

409         }

410    }

 

在这之后就是在读入时需要进行正确映射的部分，只有下面的内容得到正确映射，上面所保存的地址才有意义。接下来的部分，除去 mmi 的结构，余下部分必须在页边界上对齐（在它和 mmi 之间填 0 ），这样在提供 mmap 系统调用的目标操作系统上就能直接映射这些内容。

 

gt_pch_save (continue)

 

481      ggc_pch_prepare_write (state.d, state.f);

482   

483      /* Pad the PCH file so that the mmapped area starts on a page boundary.  */

484      {

485        long o;

486        o = ftell (state.f) + sizeof (mmi);

487        if (o == -1)

488          fatal_error ("can't get position in PCH file: %m");

489        mmi.offset = page_size - o % page_size;

490        if (mmi.offset == page_size)

491          mmi.offset = 0;

492        mmi.offset += o;

493      }

494      if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)

495        fatal_error ("can't write PCH file: %m");

496      if (mmi.offset != 0

497          && fseek (state.f, mmi.offset, SEEK_SET) != 0)

498        fatal_error ("can't write padding to PCH file: %m");

499   

500      /* Actually write out the objects.  */

501      for (i = 0; i < state.count; i++)

502      {

503        if (this_object_size < state.ptrs[i]->size)

504        {

505          this_object_size = state.ptrs[i]->size;

506          this_object = xrealloc (this_object, this_object_size);

507        }

508        memcpy (this_object, state.ptrs[i]->obj, state.ptrs[i]->size);

509        if (state.ptrs[i]->reorder_fn != NULL)

510          state.ptrs[i]->reorder_fn (state.ptrs[i]->obj,

511                                state.ptrs[i]->note_ptr_cookie,

512                               relocate_ptrs, &state);

513        state.ptrs[i]->note_ptr_fn (state.ptrs[i]->obj,

514                              state.ptrs[i]->note_ptr_cookie,

515                             relocate_ptrs , &state);

516        ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj,

517                           state.ptrs[i]->new_addr, state.ptrs[i]->size,

518                           state.ptrs[i]->note_ptr_fn == gt_pch_p_S);

519        if (state.ptrs[i]->note_ptr_fn != gt_pch_p_S)

520          memcpy (state.ptrs[i]->obj, this_object, state.ptrs[i]->size);

521      }

522      ggc_pch_finish (state.d, state.f);

523      gt_pch_fixup_stringpool ();

524   

525      free (state.ptrs);

526      htab_delete (saving_htab );

527    }

 

那么 501 行的 FOR 循环把内容更新后的 GC 管理对象写入文件。注意到它们的内容必须被更新为新地址。在数组 ptrs 中保存的对象由 gt_pch_note_object 分配而来，它们具有空的 reorder_fn ，不过填好了 note_ptr_fn 。以 cgraph_nodes_queue 为例，其 note_ptr_fn 指向 gt_pch_p_11cgraph_node 。

 

2625   void

2626   gt_pch_p_11cgraph_node (void *this_obj ATTRIBUTE_UNUSED,               in ggc-desc.c

2627        void *x_p,

2628        gt_pointer_operator op ATTRIBUTE_UNUSED,

2629        void *cookie ATTRIBUTE_UNUSED)

2630   {

2631     struct cgraph_node * const x ATTRIBUTE_UNUSED = (struct cgraph_node *)x_p;

2632     if ((void *)(x) == this_obj)

2633       op (&((*x).decl), cookie);

2634     if ((void *)(x) == this_obj)

2635       op (&((*x).callees), cookie);

2636     if ((void *)(x) == this_obj)

2637       op (&((*x).callers), cookie);

2638     if ((void *)(x) == this_obj)

2639       op (&((*x).next), cookie);

2640     if ((void *)(x) == this_obj)

2641       op (&((*x).previous), cookie);

2642     if ((void *)(x) == this_obj)

2643       op (&((*x).origin), cookie);

2644     if ((void *)(x) == this_obj)

2645       op (&((*x).nested), cookie);

2646     if ((void *)(x) == this_obj)

2647       op (&((*x).next_nested), cookie);

2648     if ((void *)(x) == this_obj)

2649       op (&((*x).next_needed), cookie);

2650   }

 

该函数调用了由 op 引用的函数来相应地更新对象中保存地址的域。通常 op 指向 relocate_ptrs 。

 

363    static void

364    relocate_ptrs (void *ptr_p, void *state_p)                                                  in ggc-common.c

365    {

366      void **ptr = (void **)ptr_p;

367      struct traversal_state *state ATTRIBUTE_UNUSED

368        = (struct traversal_state *)state_p;

369      struct ptr_data *result;

370   

371      if (*ptr == NULL || *ptr == (void *)1)

372        return ;

373   

374      result = htab_find_with_hash (saving_htab , *ptr, POINTER_HASH (*ptr));

375      if (result == NULL)

376        abort ();

377      *ptr = result->new_addr;

378    }

 

在 516 行， ggc_pch_write_object 把更新后的对象写入文件。然后 ggc_pch_finish 释放 state 中的 d 。并且 ident_hash 为 gt_pch_fixup_stringpool 所复原。

 

252    void

253    gt_pch_fixup_stringpool (void)                                                          in stringpool.c

254    {

255      ht_forall (saved_ident_hash , ht_copy_and_clear , ident_hash );

256      ht_destroy (saved_ident_hash );

257      saved_ident_hash = 0;

258    }

 

PCH 文件的最后部分是其源文件中的宏定义，及由 –MT 或 –MQ 选项所携带的依赖信息。

 

364    int

365    cpp_write_pch_state (cpp_reader *r, FILE *f)                                                  in cpppch.c

366    {

367      struct macrodef_struct z;

368   

369      /* Write out the list of defined identifiers.  */

370      cpp_forall_identifiers (r, write_macdef , f);

371      memset (&z, 0, sizeof (z));

372      if (fwrite (&z, sizeof (z), 1, f) != 1)

373      {

374        cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");

375        return -1;

376      }

377   

378      if (!r->deps)

379        r->deps = deps_init ();

380   

381      if (deps_save (r->deps, f) != 0)

382      {

383        cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");

384        return -1;

385      }

386   

387      return 0;

388    }

 

最后，一个 PCH 文件的内容显示如下。

图 118 ： PCH 文件内容