gcc/cpppch.c

   1 /* Part of CPP library.  (Precompiled header reading/writing.)
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   3
   4 This program is free software; you can redistribute it and/or modify it
   5 under the terms of the GNU General Public License as published by the
   6 Free Software Foundation; either version 2, or (at your option) any
   7 later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 #include "config.h"
  19 #include "system.h"
  20 #include "cpplib.h"
  21 #include "cpphash.h"
  22 #include "intl.h"
  23 #include "hashtab.h"
  24 #include "mkdeps.h"
  25
  26 static int write_macdef (cpp_reader *, cpp_hashnode *, void *);
  27 static int save_idents (cpp_reader *, cpp_hashnode *, void *);
  28 static hashval_t hashmem (const void *, size_t);
  29 static hashval_t cpp_string_hash (const void *);
  30 static int cpp_string_eq (const void *, const void *);
  31 static int count_defs (cpp_reader *, cpp_hashnode *, void *);
  32 static int comp_hashnodes (const void *, const void *);
  33 static int collect_ht_nodes (cpp_reader *, cpp_hashnode *, void *);
  34 static int write_defs (cpp_reader *, cpp_hashnode *, void *);
  35 static int save_macros (cpp_reader *, cpp_hashnode *, void *);
  36
  37 /* This structure represents a macro definition on disk.  */
  38 struct macrodef_struct
  39 {
  40   unsigned int definition_length;
  41   unsigned short name_length;
  42   unsigned short flags;
  43 };
  44
  45 /* This is how we write out a macro definition.
  46    Suitable for being called by cpp_forall_identifiers.  */
  47
  48 static int
  49 write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p)
  50 {
  51   FILE *f = (FILE *) file_p;
  52   switch (hn->type)
  53     {
  54     case NT_VOID:
  55       if (! (hn->flags & NODE_POISONED))
  56         return 1;
  57
  58     case NT_MACRO:
  59       if ((hn->flags & NODE_BUILTIN))
  60         return 1;
  61
  62       {
  63         struct macrodef_struct s;
  64         const unsigned char *defn;
  65
  66         s.name_length = NODE_LEN (hn);
  67         s.flags = hn->flags & NODE_POISONED;
  68
  69         if (hn->type == NT_MACRO)
  70           {
  71             defn = cpp_macro_definition (pfile, hn);
  72             s.definition_length = ustrlen (defn);
  73           }
  74         else
  75           {
  76             defn = NODE_NAME (hn);
  77             s.definition_length = s.name_length;
  78           }
  79
  80         if (fwrite (&s, sizeof (s), 1, f) != 1
  81             || fwrite (defn, 1, s.definition_length, f) != s.definition_length)
  82           {
  83             cpp_errno (pfile, CPP_DL_ERROR,
  84                        "while writing precompiled header");
  85             return 0;
  86           }
  87       }
  88       return 1;
  89
  90     case NT_ASSERTION:
  91       /* Not currently implemented.  */
  92       return 1;
  93
  94     default:
  95       abort ();
  96     }
  97 }
  98
  99 /* This structure records the names of the defined macros.
 100    It's also used as a callback structure for size_initial_idents
 101    and save_idents.  */
 102
 103 struct cpp_savedstate
 104 {
 105   /* A hash table of the defined identifiers.  */
 106   htab_t definedhash;
 107   /* The size of the definitions of those identifiers (the size of
 108      'definedstrs').  */
 109   size_t hashsize;
 110   /* Number of definitions */
 111   size_t n_defs;
 112   /* Array of definitions.  In cpp_write_pch_deps it is used for sorting.  */
 113   cpp_hashnode **defs;
 114   /* Space for the next definition.  Definitions are null-terminated
 115      strings.  */
 116   unsigned char *definedstrs;
 117 };
 118
 119 /* Save this identifier into the state: put it in the hash table,
 120    put the definition in 'definedstrs'.  */
 121
 122 static int
 123 save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
 124 {
 125   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
 126
 127   if (hn->type != NT_VOID)
 128     {
 129       struct cpp_string news;
 130       void **slot;
 131
 132       news.len = NODE_LEN (hn);
 133       news.text= NODE_NAME (hn);
 134       slot = htab_find_slot (ss->definedhash, &news, INSERT);
 135       if (*slot == NULL)
 136         {
 137           struct cpp_string *sp;
 138           unsigned char *text;
 139
 140           sp = xmalloc (sizeof (struct cpp_string));
 141           *slot = sp;
 142
 143           sp->len = NODE_LEN (hn);
 144           sp->text = text = xmalloc (NODE_LEN (hn));
 145           memcpy (text, NODE_NAME (hn), NODE_LEN (hn));
 146         }
 147     }
 148
 149   return 1;
 150 }
 151
 152 /* Hash some memory in a generic way.  */
 153
 154 static hashval_t
 155 hashmem (const void *p_p, size_t sz)
 156 {
 157   const unsigned char *p = (const unsigned char *)p_p;
 158   size_t i;
 159   hashval_t h;
 160
 161   h = 0;
 162   for (i = 0; i < sz; i++)
 163     h = h * 67 - (*p++ - 113);
 164   return h;
 165 }
 166
 167 /* Hash a cpp string for the hashtable machinery.  */
 168
 169 static hashval_t
 170 cpp_string_hash (const void *a_p)
 171 {
 172   const struct cpp_string *a = (const struct cpp_string *) a_p;
 173   return hashmem (a->text, a->len);
 174 }
 175
 176 /* Compare two cpp strings for the hashtable machinery.  */
 177
 178 static int
 179 cpp_string_eq (const void *a_p, const void *b_p)
 180 {
 181   const struct cpp_string *a = (const struct cpp_string *) a_p;
 182   const struct cpp_string *b = (const struct cpp_string *) b_p;
 183   return (a->len == b->len
 184           && memcmp (a->text, b->text, a->len) == 0);
 185 }
 186
 187 /* Save the current definitions of the cpp_reader for dependency
 188    checking purposes.  When writing a precompiled header, this should
 189    be called at the same point in the compilation as cpp_valid_state
 190    would be called when reading the precompiled header back in.  */
 191
 192 int
 193 cpp_save_state (cpp_reader *r, FILE *f)
 194 {
 195   /* Save the list of non-void identifiers for the dependency checking.  */
 196   r->savedstate = xmalloc (sizeof (struct cpp_savedstate));
 197   r->savedstate->definedhash = htab_create (100, cpp_string_hash,
 198                                             cpp_string_eq, NULL);
 199   cpp_forall_identifiers (r, save_idents, r->savedstate);
 200
 201   /* Write out the list of defined identifiers.  */
 202   cpp_forall_identifiers (r, write_macdef, f);
 203
 204   return 0;
 205 }
 206
 207 /* Calculate the 'hashsize' field of the saved state.  */
 208
 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 }
 246
 247 /* Collect the identifiers into the state's string table.  */
 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 }
 285
 286 /* Comparison function for qsort.  The arguments point to pointers of
 287    type ht_hashnode *.  */
 288 static int
 289 comp_hashnodes (const void *px, const void *py)
 290 {
 291   cpp_hashnode *x = *(cpp_hashnode **) px;
 292   cpp_hashnode *y = *(cpp_hashnode **) py;
 293   return ustrcmp (NODE_NAME (x), NODE_NAME (y));
 294 }
 295
 296 /* Write out the remainder of the dependency information.  This should be
 297    called after the PCH is ready to be saved.  */
 298
 299 int
 300 cpp_write_pch_deps (cpp_reader *r, FILE *f)
 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 }
 342
 343 /* Write out the definitions of the preprocessor, in a form suitable for
 344    cpp_read_state.  */
 345
 346 int
 347 cpp_write_pch_state (cpp_reader *r, FILE *f)
 348 {
 349   struct macrodef_struct z;
 350
 351   /* Write out the list of defined identifiers.  */
 352   cpp_forall_identifiers (r, write_macdef, f);
 353   memset (&z, 0, sizeof (z));
 354   if (fwrite (&z, sizeof (z), 1, f) != 1)
 355     {
 356       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 357       return -1;
 358     }
 359
 360   if (!r->deps)
 361     r->deps = deps_init ();
 362
 363   if (deps_save (r->deps, f) != 0)
 364     {
 365       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 366       return -1;
 367     }
 368
 369   if (! _cpp_save_file_entries (r, f))
 370     {
 371       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 372       return -1;
 373     }
 374
 375   return 0;
 376 }
 377
 378
 379 /* Data structure to transform hash table nodes into a sorted list */
 380
 381 struct ht_node_list
 382 {
 383   /* Array of nodes */
 384   cpp_hashnode **defs;
 385   /* Number of nodes in the array */
 386   size_t n_defs;
 387   /* Size of the allocated array */
 388   size_t asize;
 389 };
 390
 391 /* Callback for collecting identifiers from hash table */
 392
 393 static int
 394 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
 395                   void *nl_p)
 396 {
 397   struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
 398
 399   if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
 400     {
 401       if (nl->n_defs == nl->asize)
 402         {
 403           nl->asize *= 2;
 404           nl->defs = xrealloc (nl->defs, nl->asize * sizeof (cpp_hashnode *));
 405         }
 406
 407       nl->defs[nl->n_defs] = hn;
 408       ++nl->n_defs;
 409     }
 410   return 1;
 411 }
 412
 413
 414 /* Return nonzero if FD is a precompiled header which is consistent
 415    with the preprocessor's current definitions.  It will be consistent
 416    when:
 417
 418    - anything that was defined just before the PCH was generated
 419      is defined the same way now; and
 420    - anything that was not defined then, but is defined now, was not
 421      used by the PCH.
 422
 423    NAME is used to print warnings if `warn_invalid_pch' is set in the
 424    reader's flags.
 425 */
 426
 427 int
 428 cpp_valid_state (cpp_reader *r, const char *name, int fd)
 429 {
 430   struct macrodef_struct m;
 431   size_t namebufsz = 256;
 432   unsigned char *namebuf = xmalloc (namebufsz);
 433   unsigned char *undeftab = NULL;
 434   struct ht_node_list nl = { 0, 0, 0 };
 435   unsigned char *first, *last;
 436   unsigned int i;
 437
 438   /* Read in the list of identifiers that must be defined
 439      Check that they are defined in the same way.  */
 440   for (;;)
 441     {
 442       cpp_hashnode *h;
 443       const unsigned char *newdefn;
 444
 445       if (read (fd, &m, sizeof (m)) != sizeof (m))
 446         goto error;
 447
 448       if (m.name_length == 0)
 449         break;
 450
 451       if (m.definition_length > namebufsz)
 452         {
 453           free (namebuf);
 454           namebufsz = m.definition_length + 256;
 455           namebuf = xmalloc (namebufsz);
 456         }
 457
 458       if ((size_t)read (fd, namebuf, m.definition_length)
 459           != m.definition_length)
 460         goto error;
 461
 462       h = cpp_lookup (r, namebuf, m.name_length);
 463       if (m.flags & NODE_POISONED
 464           || h->type != NT_MACRO
 465           || h->flags & NODE_POISONED)
 466         {
 467           if (CPP_OPTION (r, warn_invalid_pch))
 468             cpp_error (r, CPP_DL_WARNING_SYSHDR,
 469                        "%s: not used because `%.*s' not defined",
 470                        name, m.name_length, namebuf);
 471           goto fail;
 472         }
 473
 474       newdefn = cpp_macro_definition (r, h);
 475
 476       if (m.definition_length != ustrlen (newdefn)
 477           || memcmp (namebuf, newdefn, m.definition_length) != 0)
 478         {
 479           if (CPP_OPTION (r, warn_invalid_pch))
 480             cpp_error (r, CPP_DL_WARNING_SYSHDR,
 481                "%s: not used because `%.*s' defined as `%s' not `%.*s'",
 482                        name, m.name_length, namebuf, newdefn + m.name_length,
 483                        m.definition_length - m.name_length,
 484                        namebuf +  m.name_length);
 485           goto fail;
 486         }
 487     }
 488   free (namebuf);
 489   namebuf = NULL;
 490
 491   /* Read in the list of identifiers that must not be defined.
 492      Check that they really aren't.  */
 493   undeftab = xmalloc (m.definition_length);
 494   if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
 495     goto error;
 496
 497   /* Collect identifiers from the current hash table.  */
 498   nl.n_defs = 0;
 499   nl.asize = 10;
 500   nl.defs = xmalloc (nl.asize * sizeof (cpp_hashnode *));
 501   cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
 502   qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
 503
 504   /* Loop through nl.defs and undeftab, both of which are sorted lists.
 505      There should be no matches.  */
 506   first = undeftab;
 507   last = undeftab + m.definition_length;
 508   i = 0;
 509
 510   while (first < last && i < nl.n_defs)
 511     {
 512       int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
 513
 514       if (cmp < 0)
 515         first += ustrlen (first) + 1;
 516       else if (cmp > 0)
 517         ++i;
 518       else
 519         {
 520           if (CPP_OPTION (r, warn_invalid_pch))
 521             cpp_error (r, CPP_DL_WARNING_SYSHDR,
 522                        "%s: not used because `%s' is defined",
 523                        name, first);
 524           goto fail;
 525         }
 526     }
 527
 528   free(nl.defs);
 529   free (undeftab);
 530
 531   /* We win!  */
 532   return 0;
 533
 534  error:
 535   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
 536   return -1;
 537
 538  fail:
 539   if (namebuf != NULL)
 540     free (namebuf);
 541   if (undeftab != NULL)
 542     free (undeftab);
 543   if (nl.defs != NULL)
 544     free (nl.defs);
 545   return 1;
 546 }
 547
 548 /* Save all the existing macros and assertions.
 549    This code assumes that there might be hundreds, but not thousands of
 550    existing definitions.  */
 551
 552 struct save_macro_item {
 553   struct save_macro_item *next;
 554   struct cpp_hashnode macs[64];
 555 };
 556
 557 struct save_macro_data
 558 {
 559   struct save_macro_item *macros;
 560   size_t count;
 561   char **saved_pragmas;
 562 };
 563
 564 /* Save the definition of a single macro, so that it will persist across
 565    a PCH restore.  */
 566
 567 static int
 568 save_macros (cpp_reader *r ATTRIBUTE_UNUSED, cpp_hashnode *h, void *data_p)
 569 {
 570   struct save_macro_data *data = (struct save_macro_data *)data_p;
 571   if (h->type != NT_VOID
 572       && (h->flags & NODE_BUILTIN) == 0)
 573     {
 574       cpp_hashnode *save;
 575       if (data->count == ARRAY_SIZE (data->macros->macs))
 576         {
 577           struct save_macro_item *d = data->macros;
 578           data->macros = xmalloc (sizeof (struct save_macro_item));
 579           data->macros->next = d;
 580           data->count = 0;
 581         }
 582       save = data->macros->macs + data->count;
 583       data->count++;
 584       memcpy (save, h, sizeof (struct cpp_hashnode));
 585       HT_STR (&save->ident) = xmemdup (HT_STR (HT_NODE (save)),
 586                                        HT_LEN (HT_NODE (save)),
 587                                        HT_LEN (HT_NODE (save)) + 1);
 588     }
 589   return 1;
 590 }
 591
 592 /* Prepare to restore the state, by saving the currently-defined
 593    macros in 'data'.  */
 594
 595 void
 596 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
 597 {
 598   struct save_macro_data *d = xmalloc (sizeof (struct save_macro_data));
 599
 600   d->macros = NULL;
 601   d->count = ARRAY_SIZE (d->macros->macs);
 602   cpp_forall_identifiers (r, save_macros, d);
 603   d->saved_pragmas = _cpp_save_pragma_names (r);
 604   *data = d;
 605 }
 606
 607 /* Given a precompiled header that was previously determined to be valid,
 608    apply all its definitions (and undefinitions) to the current state.
 609    DEPNAME is passed to deps_restore.  */
 610
 611 int
 612 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
 613                 struct save_macro_data *data)
 614 {
 615   struct macrodef_struct m;
 616   size_t defnlen = 256;
 617   unsigned char *defn = xmalloc (defnlen);
 618   struct lexer_state old_state;
 619   struct save_macro_item *d;
 620   size_t i, mac_count;
 621   int saved_line = r->line;
 622
 623   /* Restore spec_nodes, which will be full of references to the old
 624      hashtable entries and so will now be invalid.  */
 625   {
 626     struct spec_nodes *s = &r->spec_nodes;
 627     s->n_defined        = cpp_lookup (r, DSC("defined"));
 628     s->n_true           = cpp_lookup (r, DSC("true"));
 629     s->n_false          = cpp_lookup (r, DSC("false"));
 630     s->n__VA_ARGS__     = cpp_lookup (r, DSC("__VA_ARGS__"));
 631   }
 632
 633   /* Run through the carefully-saved macros, insert them.  */
 634   d = data->macros;
 635   mac_count = data->count;
 636   while (d)
 637     {
 638       struct save_macro_item *nextd;
 639       for (i = 0; i < mac_count; i++)
 640         {
 641           cpp_hashnode *h;
 642
 643           h = cpp_lookup (r, HT_STR (HT_NODE (&d->macs[i])),
 644                           HT_LEN (HT_NODE (&d->macs[i])));
 645           h->type = d->macs[i].type;
 646           h->flags = d->macs[i].flags;
 647           h->value = d->macs[i].value;
 648           free ((void *)HT_STR (HT_NODE (&d->macs[i])));
 649         }
 650       nextd = d->next;
 651       free (d);
 652       d = nextd;
 653       mac_count = ARRAY_SIZE (d->macs);
 654     }
 655
 656   _cpp_restore_pragma_names (r, data->saved_pragmas);
 657
 658   free (data);
 659
 660   old_state = r->state;
 661
 662   r->state.in_directive = 1;
 663   r->state.prevent_expansion = 1;
 664   r->state.angled_headers = 0;
 665
 666   /* Read in the identifiers that must be defined.  */
 667   for (;;)
 668     {
 669       cpp_hashnode *h;
 670
 671       if (fread (&m, sizeof (m), 1, f) != 1)
 672         goto error;
 673
 674       if (m.name_length == 0)
 675         break;
 676
 677       if (defnlen < m.definition_length + 1)
 678         {
 679           defnlen = m.definition_length + 256;
 680           defn = xrealloc (defn, defnlen);
 681         }
 682
 683       if (fread (defn, 1, m.definition_length, f) != m.definition_length)
 684         goto error;
 685       defn[m.definition_length] = '\n';
 686
 687       h = cpp_lookup (r, defn, m.name_length);
 688
 689       if (h->type == NT_MACRO)
 690         _cpp_free_definition (h);
 691       if (m.flags & NODE_POISONED)
 692         h->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
 693       else if (m.name_length != m.definition_length)
 694         {
 695           if (cpp_push_buffer (r, defn + m.name_length,
 696                                m.definition_length - m.name_length, true)
 697               != NULL)
 698             {
 699               _cpp_clean_line (r);
 700               if (!_cpp_create_definition (r, h))
 701                 abort ();
 702               _cpp_pop_buffer (r);
 703             }
 704           else
 705             abort ();
 706         }
 707     }
 708
 709   r->state = old_state;
 710   r->line = saved_line;
 711   free (defn);
 712   defn = NULL;
 713
 714   if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
 715       != 0)
 716     goto error;
 717
 718   if (! _cpp_read_file_entries (r, f))
 719     goto error;
 720
 721   return 0;
 722
 723  error:
 724   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
 725   return -1;
 726 }