Studying note of GCC-3.4.6 source (31)

4.1.3.1.1.1.      Validate PCH File

If PCH file is found, it needs ensure this file is valid.

 

1257 static bool

1258 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)          in cppfiles.c

1259 {

1260   const char *saved_path = file->path;

1261   bool valid = false;

1262

1263   file->path = pchname;

1264   if (open_file (file))

1265   {

1266     valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);

1267

1268     if (!valid)

1269     {

1270       close (file->fd);

1271       file->fd = -1;

1272     }

1273

1274     if (CPP_OPTION (pfile, print_include_names))

1275     {

1276       unsigned int i;

1277       for (i = 1; i < pfile->line_maps.depth; i++)

1278         putc ('.', stderr);

1279       fprintf (stderr, "%c %s/n",

1280             valid ? '!' : 'x', pchname);

1281     }

1282   }

1283

1284   file->path = saved_path;

1285   return valid;

1286 }

 

The format of pre-compiled header is not unified yet, it is possible GCC will adopt other format in future, thus cpp_reader provides the hook cb to bind up operating functions for the specified pre-compiled header format. For C++/C, init_c_lex does the binding. The definition of the hook cb is as below, only the last 2 fields are used for pre-compiled header, and other fields also provide flexibility for the corresponding operation.

 

379  struct cpp_callbacks                                                                                    in cpplib.h

380  {

381    /* Called when a new line of preprocessed output is started.  */

382    void (*line_change) (cpp_reader *, const cpp_token *, int);

383 

384    /* Called when switching to/from a new file.

385      The line_map is for the new file. It is NULL if there is no new file.

386      (In C this happens when done with <built-in>+<command line> and also

387      when done with a main file.)  This can be used for resource cleanup.  */

388    void (*file_change) (cpp_reader *, const struct line_map *);

389 

390    void (*dir_change) (cpp_reader *, const char *);

391    void (*include) (cpp_reader *, unsigned int, const unsigned char *,

392                   const char *, int);

393    void (*define) (cpp_reader *, unsigned int, cpp_hashnode *);

394    void (*undef) (cpp_reader *, unsigned int, cpp_hashnode *);

395    void (*ident) (cpp_reader *, unsigned int, const cpp_string *);

396    void (*def_pragma) (cpp_reader *, unsigned int);

397    int (*valid_pch) (cpp_reader *, const char *, int);

398    void (*read_pch) (cpp_reader *, const char *, int, const char *);

399  };

 

Now valid_pch is c_common_valid_pch for C/C++. For PCH file, the very begnning of the file conatins 8 bytes of identification followed by a struct c_pch_validity defined as below.

 

53    struct c_pch_validity                                                                                   in c-pch.c

54    {

55      unsigned char host_machine_length;

56      unsigned char target_machine_length;

57      unsigned char version_length;

58      unsigned char debug_info_type;

59      unsigned int flags_info;

60      void (*pch_init) (void);

61      size_t target_data_length;

62    };

 

In c_common_valid_pch, it is easy to find that a common PCH file will contain following content at beginning:

Figure 9 Layout of PCH file

Field debug_info_type indicates the type of debug information generated, and field flags_info is set if switch -funit-at-a-time is in used when generating the PCH file.

 

219  int

220  c_common_valid_pch (cpp_reader *pfile, const char *name, int fd)                in c-pch.c

221  {

222    int sizeread;

223    int result;

224    char ident[IDENT_LENGTH];

225    char short_strings[256 * 3];

226    int strings_length;

227    const char *pch_ident;

228    struct c_pch_validity v;

229    unsigned int current_flags_info = 0;

230 

231    if (flag_unit_at_a_time)

232      current_flags_info |= FLAG_UNIT_AT_A_TIME_SET;

233 

234    /* Perform a quick test of whether this is a valid

235      precompiled header for the current language

236      and with the current flag settings.  */

237 

238    sizeread = read (fd, ident, IDENT_LENGTH);

239    if (sizeread == -1)

240      fatal_error ("can't read %s: %m", name);

241    else if (sizeread != IDENT_LENGTH)

242      return 2;

243   

244    pch_ident = get_ident();

245    if (memcmp (ident, pch_ident, IDENT_LENGTH) != 0)

246    {

247      if (cpp_get_options (pfile)->warn_invalid_pch)

248      {

249        if (memcmp (ident, pch_ident, 5) == 0)

250          /* It's a PCH, for the right language, but has the wrong version.

251           */

252          cpp_error (pfile, CPP_DL_WARNING,

253                   "%s: not compatible with this GCC version", name);

254        else if (memcmp (ident, pch_ident, 4) == 0)

255          /* It's a PCH for the wrong language.  */

256          cpp_error (pfile, CPP_DL_WARNING, "%s: not for %s", name,

257                   lang_hooks.name);

258        else

259           /* Not any kind of PCH.  */

260           cpp_error (pfile, CPP_DL_WARNING, "%s: not a PCH file", name);

261      }

262      return 2;

263    }

264 

265    /* At this point, we know it's a PCH file, so it ought to be long enough

266      that we can read a c_pch_validity structure.  */

267    if (read (fd, &v, sizeof (v)) != sizeof (v))

268      fatal_error ("can't read %s: %m", name);

269 

270    strings_length = (v.host_machine_length + v.target_machine_length

271                    + v.version_length);

272    if (read (fd, short_strings, strings_length) != strings_length)

273      fatal_error ("can't read %s: %m", name);

274    if (v.host_machine_length != strlen (host_machine)

275        || memcmp (host_machine, short_strings, strlen (host_machine)) != 0)

276    {

277      if (cpp_get_options (pfile)->warn_invalid_pch)

278        cpp_error (pfile, CPP_DL_WARNING,

279                   "%s: created on host `%.*s', but used on host `%s'", name,

280                   v.host_machine_length, short_strings, host_machine);

281        return 2;

282    }

283    if (v.target_machine_length != strlen (target_machine)

284        || memcmp (target_machine, short_strings + v.host_machine_length,

285                strlen (target_machine)) != 0)

286    {

287      if (cpp_get_options (pfile)->warn_invalid_pch)

288        cpp_error (pfile, CPP_DL_WARNING,

289                   "%s: created for target `%.*s', but used for target `%s'",

290                   name, v.target_machine_length,

291                   short_strings + v.host_machine_length, target_machine);

292        return 2;

293    }

294    if (v.version_length != strlen (version_string)

295        || memcmp (version_string,

296                  (short_strings + v.host_machine_length

297                   + v.target_machine_length),

298                   v.version_length) != 0)

299    {

300      if (cpp_get_options (pfile)->warn_invalid_pch)

301        cpp_error (pfile, CPP_DL_WARNING,

302                   "%s: created by version `%.*s', but this is version `%s'",

303                   name, v.version_length,

304                   (short_strings + v.host_machine_length

305                    + v.target_machine_length),

306                   version_string);

307        return 2;

308    }

309    if (v.flags_info != current_flags_info)

310    {

311      if (cpp_get_options (pfile)->warn_invalid_pch)

312        cpp_error (pfile, CPP_DL_WARNING,

313                   "%s: created using different flags",

314                   name);

315      return 2;

316    }

317 

318    /* The allowable debug info combinations are that either the PCH file

319      was built with the same as is being used now, or the PCH file was

320      built for some kind of debug info but now none is in use.  */

321   if (v.debug_info_type != write_symbols

322        && write_symbols != NO_DEBUG)

323    {

324      if (cpp_get_options (pfile)->warn_invalid_pch)

325        cpp_error (pfile, CPP_DL_WARNING,

326                   "%s: created with -g%s, but used with -g%s", name,

327                   debug_type_names[v.debug_info_type],

328                   debug_type_names[write_symbols]);

329      return 2;

330    }

331 

332   /* If the text segment was not loaded at the same address as it was

333      when the PCH file was created, function pointers loaded from the

334      PCH will not be valid. We could in theory remap all the function

335      pointers, but no support for that exists at present.  */

336    if (v.pch_init != &pch_init)

337    {

338      if (cpp_get_options (pfile)->warn_invalid_pch)

339        cpp_error (pfile, CPP_DL_WARNING,

340                   "%s: had text segment at different address", name);

341      return 2;

342    }

343 

344    /* Check the target-specific validity data.  */

345    {

346      void *this_file_data = xmalloc (v.target_data_length);

347      const char *msg;

348     

349      if ((size_t) read (fd, this_file_data, v.target_data_length)

350          != v.target_data_length)

351        fatal_error ("can't read %s: %m", name);

352      msg = targetm.pch_valid_p (this_file_data, v.target_data_length);

353      free (this_file_data);

354      if (msg != NULL)

355      {

356        if (cpp_get_options (pfile)->warn_invalid_pch)

357          cpp_error (pfile, CPP_DL_WARNING, "%s: %s", name, msg);

358        return 2;

359      }

360    }

361 

362    /* Check the preprocessor macros are the same as when the PCH was

363      generated.  */

364   

365    result = cpp_valid_state (pfile, name, fd);

366    if (result == -1)

367      return 2;

368    else

369      return result == 0;

370  }

 

If fields before target_data are valid, the immediate validation of this data is done target depenedent. However, for most targets GCC currently support, the default mehod is enough.

 

4112 const char *

4113 default_pch_valid_p (const void *data_p, size_t len)                                     in toplev.c

4114 {

4115   const char *data = (const char *)data_p;

4116   const char *flag_that_differs = NULL;

4117   size_t i;

4118

4119   /* -fpic and -fpie also usually make a PCH invalid.  */

4120   if (data[0] != flag_pic)

4121     return _("created and used with different settings of -fpic");

4122   if (data[1] != flag_pie)

4123     return _("created and used with different settings of -fpie");

4124   data += 2;

4125

4126   /* Check target_flags.  */

4127   if (memcmp (data, &target_flags, sizeof (target_flags)) != 0)

4128   {

4129     for (i = 0; i < ARRAY_SIZE (target_switches); i++)

4130     {

4131       int bits;

4132       int tf;

4133

4134       memcpy (&tf, data, sizeof (target_flags));

4135

4136       bits = target_switches[i].value;

4137       if (bits < 0)

4138         bits = -bits;

4139       if ((target_flags & bits) != (tf & bits))

4140       {

4141         flag_that_differs = target_switches[i].name;

4142         goto make_message;

4143       }

4144     }

4145     abort ();

4146   }

4147   data += sizeof (target_flags);

4148   len -= sizeof (target_flags);

4149

4150   /* Check string options.  */

4151 #ifdef TARGET_OPTIONS

4152   for (i = 0; i < ARRAY_SIZE (target_options); i++)

4153   {

4154     const char *str = *target_options[i].variable;

4155     size_t l;

4156     if (! str)

4157       str = "";

4158     l = strlen (str) + 1;

4159     if (len < l || memcmp (data, str, l) != 0)

4160     {

4161       flag_that_differs = target_options[i].prefix;

4162       goto make_message;

4163     }

4164     data += l;

4165     len -= l;

4166   }

4167 #endif

4168

4169   return NULL;

4170

4171  make_message:

4172   {

4173     char *r;

4174     asprintf (&r, _("created and used with differing settings of `-m%s'"),

4175                flag_that_differs);

4176     if (r == NULL)

4177       return _("out of memory");

4178     return r;

4179   }

4180 }

 

In the function, can see that target_data contains following information. For the setting and meaning of target_flags and target_options refers to Initializing options related to target. Being validate PCH file, its target_data must exactly matches corresponding data current in used. Notice that in target_options part in the data, all target options must appear, and for those not used only “/0” will be present.

 

Figure 10 Layout of target data of PCH file

If the PCH file is validate, it is what we want, so we can return at line 326 in find_file_in_dir, othewise just try to open the normal file.

 

_cpp_find_file (continue)

 

418      if (entry)

419      {

420        /* Cache for START_DIR too, sharing the _cpp_file structure.  */

421       free ((char *) file->name);

422        free (file);

423        file = entry->u.file;

424      }

425      else

426      {

427        /* This is a new file; put it in the list.  */

428        file->next_file = pfile->all_files;

429        pfile->all_files = file;

430      }

431   

432      /* Store this new result in the hash table.  */

433      entry = new_file_hash_entry (pfile);

434      entry->next = *hash_slot;

435      entry->start_dir = start_dir;

436      entry->u.file = file;

437      *hash_slot = entry;

438   

439      return file;

440    }

 

If entry at line 418 is not NULL, it means find out the expected file, but not within start_dir. To prevent later lookup in the directory for the same file from duplicate hard search, it is preferred to create a new entry to bind start_dir with the file.