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