libcpp/pch.c

   1 /* Part of CPP library.  (Precompiled header reading/writing.)
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
   3    Free Software Foundation, Inc.
   4
   5 This program is free software; you can redistribute it and/or modify it
   6 under the terms of the GNU General Public License as published by the
   7 Free Software Foundation; either version 2, or (at your option) any
   8 later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  18
  19 #include "config.h"
  20 #include "system.h"
  21 #include "cpplib.h"
  22 #include "internal.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 = XNEW (struct cpp_string);
 141           *slot = sp;
 142
 143           sp->len = NODE_LEN (hn);
 144           sp->text = text = XNEWVEC (unsigned char, 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 = XNEW (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 = (void **) 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 = (void **) 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 = XNEWVEC (cpp_hashnode *, ss->n_defs);
 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 = XNEWVEC (unsigned char, 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
 341   /* Save the next value of __COUNTER__. */
 342   if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
 343     {
 344       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 345       return -1;
 346     }
 347
 348   return 0;
 349 }
 350
 351 /* Write out the definitions of the preprocessor, in a form suitable for
 352    cpp_read_state.  */
 353
 354 int
 355 cpp_write_pch_state (cpp_reader *r, FILE *f)
 356 {
 357   if (!r->deps)
 358     r->deps = deps_init ();
 359
 360   if (deps_save (r->deps, f) != 0)
 361     {
 362       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 363       return -1;
 364     }
 365
 366   if (! _cpp_save_file_entries (r, f))
 367     {
 368       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 369       return -1;
 370     }
 371
 372   /* Save the next __COUNTER__ value.  When we include a precompiled header,
 373      we need to start at the offset we would have if the header had been
 374      included normally. */
 375   if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
 376     {
 377       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 378       return -1;
 379     }
 380
 381   return 0;
 382 }
 383
 384
 385 /* Data structure to transform hash table nodes into a sorted list */
 386
 387 struct ht_node_list
 388 {
 389   /* Array of nodes */
 390   cpp_hashnode **defs;
 391   /* Number of nodes in the array */
 392   size_t n_defs;
 393   /* Size of the allocated array */
 394   size_t asize;
 395 };
 396
 397 /* Callback for collecting identifiers from hash table */
 398
 399 static int
 400 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
 401                   void *nl_p)
 402 {
 403   struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
 404
 405   if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
 406     {
 407       if (nl->n_defs == nl->asize)
 408         {
 409           nl->asize *= 2;
 410           nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize);
 411         }
 412
 413       nl->defs[nl->n_defs] = hn;
 414       ++nl->n_defs;
 415     }
 416   return 1;
 417 }
 418
 419
 420 /* Return nonzero if FD is a precompiled header which is consistent
 421    with the preprocessor's current definitions.  It will be consistent
 422    when:
 423
 424    - anything that was defined just before the PCH was generated
 425      is defined the same way now; and
 426    - anything that was not defined then, but is defined now, was not
 427      used by the PCH.
 428
 429    NAME is used to print warnings if `warn_invalid_pch' is set in the
 430    reader's flags.
 431 */
 432
 433 int
 434 cpp_valid_state (cpp_reader *r, const char *name, int fd)
 435 {
 436   struct macrodef_struct m;
 437   size_t namebufsz = 256;
 438   unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz);
 439   unsigned char *undeftab = NULL;
 440   struct ht_node_list nl = { 0, 0, 0 };
 441   unsigned char *first, *last;
 442   unsigned int i;
 443   unsigned int counter;
 444
 445   /* Read in the list of identifiers that must be defined
 446      Check that they are defined in the same way.  */
 447   for (;;)
 448     {
 449       cpp_hashnode *h;
 450       const unsigned char *newdefn;
 451
 452       if (read (fd, &m, sizeof (m)) != sizeof (m))
 453         goto error;
 454
 455       if (m.name_length == 0)
 456         break;
 457
 458       /* If this file is already preprocessed, there won't be any
 459          macros defined, and that's OK.  */
 460       if (CPP_OPTION (r, preprocessed))
 461         {
 462           if (lseek (fd, m.definition_length, SEEK_CUR) == -1)
 463             goto error;
 464           continue;
 465         }
 466
 467       if (m.definition_length > namebufsz)
 468         {
 469           free (namebuf);
 470           namebufsz = m.definition_length + 256;
 471           namebuf = XNEWVEC (unsigned char, namebufsz);
 472         }
 473
 474       if ((size_t)read (fd, namebuf, m.definition_length)
 475           != m.definition_length)
 476         goto error;
 477
 478       h = cpp_lookup (r, namebuf, m.name_length);
 479       if (m.flags & NODE_POISONED
 480           || h->type != NT_MACRO
 481           || h->flags & NODE_POISONED)
 482         {
 483           if (CPP_OPTION (r, warn_invalid_pch))
 484             cpp_error (r, CPP_DL_WARNING_SYSHDR,
 485                        "%s: not used because `%.*s' not defined",
 486                        name, m.name_length, namebuf);
 487           goto fail;
 488         }
 489
 490       newdefn = cpp_macro_definition (r, h);
 491
 492       if (m.definition_length != ustrlen (newdefn)
 493           || memcmp (namebuf, newdefn, m.definition_length) != 0)
 494         {
 495           if (CPP_OPTION (r, warn_invalid_pch))
 496             cpp_error (r, CPP_DL_WARNING_SYSHDR,
 497                "%s: not used because `%.*s' defined as `%s' not `%.*s'",
 498                        name, m.name_length, namebuf, newdefn + m.name_length,
 499                        m.definition_length - m.name_length,
 500                        namebuf +  m.name_length);
 501           goto fail;
 502         }
 503     }
 504   free (namebuf);
 505   namebuf = NULL;
 506
 507   /* Read in the list of identifiers that must not be defined.
 508      Check that they really aren't.  */
 509   undeftab = XNEWVEC (unsigned char, m.definition_length);
 510   if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
 511     goto error;
 512
 513   /* Collect identifiers from the current hash table.  */
 514   nl.n_defs = 0;
 515   nl.asize = 10;
 516   nl.defs = XNEWVEC (cpp_hashnode *, nl.asize);
 517   cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
 518   qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
 519
 520   /* Loop through nl.defs and undeftab, both of which are sorted lists.
 521      There should be no matches.  */
 522   first = undeftab;
 523   last = undeftab + m.definition_length;
 524   i = 0;
 525
 526   while (first < last && i < nl.n_defs)
 527     {
 528       int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
 529
 530       if (cmp < 0)
 531         first += ustrlen (first) + 1;
 532       else if (cmp > 0)
 533         ++i;
 534       else
 535         {
 536           if (CPP_OPTION (r, warn_invalid_pch))
 537             cpp_error (r, CPP_DL_WARNING_SYSHDR,
 538                        "%s: not used because `%s' is defined",
 539                        name, first);
 540           goto fail;
 541         }
 542     }
 543
 544   free(nl.defs);
 545   nl.defs = NULL;
 546   free (undeftab);
 547   undeftab = NULL;
 548
 549   /* Read in the next value of __COUNTER__.
 550      Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
 551      has not been used in this translation unit. */
 552   if (read (fd, &counter, sizeof (counter)) != sizeof (counter))
 553     goto error;
 554   if (counter && r->counter)
 555     {
 556       if (CPP_OPTION (r, warn_invalid_pch))
 557         cpp_error (r, CPP_DL_WARNING_SYSHDR,
 558                    "%s: not used because `__COUNTER__' is invalid",
 559                    name);
 560         goto fail;
 561     }
 562
 563   /* We win!  */
 564   return 0;
 565
 566  error:
 567   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
 568   return -1;
 569
 570  fail:
 571   if (namebuf != NULL)
 572     free (namebuf);
 573   if (undeftab != NULL)
 574     free (undeftab);
 575   if (nl.defs != NULL)
 576     free (nl.defs);
 577   return 1;
 578 }
 579
 580 /* Save all the existing macros.  */
 581
 582 struct save_macro_data
 583 {
 584   uchar **defns;
 585   size_t count;
 586   size_t array_size;
 587   char **saved_pragmas;
 588 };
 589
 590 /* Save the definition of a single macro, so that it will persist
 591    across a PCH restore.  Because macro data is in GCed memory, which
 592    will be blown away by PCH, it must be temporarily copied to
 593    malloced memory.  (The macros will refer to identifier nodes which
 594    are also GCed and so on, so the copying is done by turning them
 595    into self-contained strings.)  The assumption is that most macro
 596    definitions will come from the PCH file, not from the compilation
 597    before the PCH file is loaded, so it doesn't matter that this is
 598    a little expensive.
 599
 600    It would reduce the cost even further if macros defined in the PCH
 601    file were not saved in this way, but this is not done (yet), except
 602    for builtins, and for #assert by default.  */
 603
 604 static int
 605 save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
 606 {
 607   struct save_macro_data *data = (struct save_macro_data *)data_p;
 608   if (h->type != NT_VOID
 609       && (h->flags & NODE_BUILTIN) == 0)
 610     {
 611       if (data->count == data->array_size)
 612         {
 613           data->array_size *= 2;
 614           data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size));
 615         }
 616
 617       switch (h->type)
 618         {
 619         case NT_ASSERTION:
 620           /* Not currently implemented.  */
 621           return 1;
 622
 623         case NT_MACRO:
 624           {
 625             const uchar * defn = cpp_macro_definition (r, h);
 626             size_t defnlen = ustrlen (defn);
 627
 628             data->defns[data->count] = (uchar *) xmemdup (defn, defnlen,
 629                                                           defnlen + 2);
 630             data->defns[data->count][defnlen] = '\n';
 631           }
 632           break;
 633
 634         default:
 635           abort ();
 636         }
 637       data->count++;
 638     }
 639   return 1;
 640 }
 641
 642 /* Prepare to restore the state, by saving the currently-defined
 643    macros in 'data'.  */
 644
 645 void
 646 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
 647 {
 648   struct save_macro_data *d = XNEW (struct save_macro_data);
 649
 650   d->array_size = 512;
 651   d->defns = XNEWVEC (uchar *, d->array_size);
 652   d->count = 0;
 653   cpp_forall_identifiers (r, save_macros, d);
 654   d->saved_pragmas = _cpp_save_pragma_names (r);
 655   *data = d;
 656 }
 657
 658 /* Given a precompiled header that was previously determined to be valid,
 659    apply all its definitions (and undefinitions) to the current state.
 660    DEPNAME is passed to deps_restore.  */
 661
 662 int
 663 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
 664                 struct save_macro_data *data)
 665 {
 666   size_t i;
 667   struct lexer_state old_state;
 668   unsigned int counter;
 669
 670   /* Restore spec_nodes, which will be full of references to the old
 671      hashtable entries and so will now be invalid.  */
 672   {
 673     struct spec_nodes *s = &r->spec_nodes;
 674     s->n_defined        = cpp_lookup (r, DSC("defined"));
 675     s->n_true           = cpp_lookup (r, DSC("true"));
 676     s->n_false          = cpp_lookup (r, DSC("false"));
 677     s->n__VA_ARGS__     = cpp_lookup (r, DSC("__VA_ARGS__"));
 678   }
 679
 680   old_state = r->state;
 681   r->state.in_directive = 1;
 682   r->state.prevent_expansion = 1;
 683   r->state.angled_headers = 0;
 684
 685   /* Run through the carefully-saved macros, insert them.  */
 686   for (i = 0; i < data->count; i++)
 687     {
 688       cpp_hashnode *h;
 689       size_t namelen;
 690       uchar *defn;
 691
 692       namelen = ustrcspn (data->defns[i], "( \n");
 693       h = cpp_lookup (r, data->defns[i], namelen);
 694       defn = data->defns[i] + namelen;
 695
 696       /* The PCH file is valid, so we know that if there is a definition
 697          from the PCH file it must be the same as the one we had
 698          originally, and so do not need to restore it.  */
 699       if (h->type == NT_VOID)
 700         {
 701           if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true)
 702               != NULL)
 703             {
 704               _cpp_clean_line (r);
 705               if (!_cpp_create_definition (r, h))
 706                 abort ();
 707               _cpp_pop_buffer (r);
 708             }
 709           else
 710             abort ();
 711         }
 712
 713       free (data->defns[i]);
 714     }
 715   r->state = old_state;
 716
 717   _cpp_restore_pragma_names (r, data->saved_pragmas);
 718
 719   free (data);
 720
 721   if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
 722       != 0)
 723     goto error;
 724
 725   if (! _cpp_read_file_entries (r, f))
 726     goto error;
 727
 728   if (fread (&counter, sizeof (counter), 1, f) != 1)
 729     goto error;
 730
 731   if (!r->counter)
 732     r->counter = counter;
 733
 734   return 0;
 735
 736  error:
 737   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
 738   return -1;
 739 }