libcpp/pch.c

   1 /* Part of CPP library.  (Precompiled header reading/writing.)
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
   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 3, 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; see the file COPYING3.  If not see
  17 <http://www.gnu.org/licenses/>.  */
  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 static int _cpp_save_pushed_macros (cpp_reader *, FILE *);
  37 static int _cpp_restore_pushed_macros (cpp_reader *, FILE *);
  38
  39 /* This structure represents a macro definition on disk.  */
  40 struct macrodef_struct
  41 {
  42   unsigned int definition_length;
  43   unsigned short name_length;
  44   unsigned short flags;
  45 };
  46
  47 /* This is how we write out a macro definition.
  48    Suitable for being called by cpp_forall_identifiers.  */
  49
  50 static int
  51 write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p)
  52 {
  53   FILE *f = (FILE *) file_p;
  54   switch (hn->type)
  55     {
  56     case NT_VOID:
  57       if (! (hn->flags & NODE_POISONED))
  58         return 1;
  59
  60     case NT_MACRO:
  61       if ((hn->flags & NODE_BUILTIN)
  62           && (!pfile->cb.user_builtin_macro
  63               || !pfile->cb.user_builtin_macro (pfile, hn)))
  64         return 1;
  65
  66       {
  67         struct macrodef_struct s;
  68         const unsigned char *defn;
  69
  70         s.name_length = NODE_LEN (hn);
  71         s.flags = hn->flags & NODE_POISONED;
  72
  73         if (hn->type == NT_MACRO)
  74           {
  75             defn = cpp_macro_definition (pfile, hn);
  76             s.definition_length = ustrlen (defn);
  77           }
  78         else
  79           {
  80             defn = NODE_NAME (hn);
  81             s.definition_length = s.name_length;
  82           }
  83
  84         if (fwrite (&s, sizeof (s), 1, f) != 1
  85             || fwrite (defn, 1, s.definition_length, f) != s.definition_length)
  86           {
  87             cpp_errno (pfile, CPP_DL_ERROR,
  88                        "while writing precompiled header");
  89             return 0;
  90           }
  91       }
  92       return 1;
  93
  94     case NT_ASSERTION:
  95       /* Not currently implemented.  */
  96       return 1;
  97
  98     default:
  99       abort ();
 100     }
 101 }
 102
 103 /* This structure records the names of the defined macros.
 104    It's also used as a callback structure for size_initial_idents
 105    and save_idents.  */
 106
 107 struct cpp_savedstate
 108 {
 109   /* A hash table of the defined identifiers.  */
 110   htab_t definedhash;
 111   /* The size of the definitions of those identifiers (the size of
 112      'definedstrs').  */
 113   size_t hashsize;
 114   /* Number of definitions */
 115   size_t n_defs;
 116   /* Array of definitions.  In cpp_write_pch_deps it is used for sorting.  */
 117   cpp_hashnode **defs;
 118   /* Space for the next definition.  Definitions are null-terminated
 119      strings.  */
 120   unsigned char *definedstrs;
 121 };
 122
 123 /* Save this identifier into the state: put it in the hash table,
 124    put the definition in 'definedstrs'.  */
 125
 126 static int
 127 save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
 128 {
 129   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
 130
 131   if (hn->type != NT_VOID)
 132     {
 133       struct cpp_string news;
 134       void **slot;
 135
 136       news.len = NODE_LEN (hn);
 137       news.text= NODE_NAME (hn);
 138       slot = htab_find_slot (ss->definedhash, &news, INSERT);
 139       if (*slot == NULL)
 140         {
 141           struct cpp_string *sp;
 142           unsigned char *text;
 143
 144           sp = XNEW (struct cpp_string);
 145           *slot = sp;
 146
 147           sp->len = NODE_LEN (hn);
 148           sp->text = text = XNEWVEC (unsigned char, NODE_LEN (hn));
 149           memcpy (text, NODE_NAME (hn), NODE_LEN (hn));
 150         }
 151     }
 152
 153   return 1;
 154 }
 155
 156 /* Hash some memory in a generic way.  */
 157
 158 static hashval_t
 159 hashmem (const void *p_p, size_t sz)
 160 {
 161   const unsigned char *p = (const unsigned char *)p_p;
 162   size_t i;
 163   hashval_t h;
 164
 165   h = 0;
 166   for (i = 0; i < sz; i++)
 167     h = h * 67 - (*p++ - 113);
 168   return h;
 169 }
 170
 171 /* Hash a cpp string for the hashtable machinery.  */
 172
 173 static hashval_t
 174 cpp_string_hash (const void *a_p)
 175 {
 176   const struct cpp_string *a = (const struct cpp_string *) a_p;
 177   return hashmem (a->text, a->len);
 178 }
 179
 180 /* Compare two cpp strings for the hashtable machinery.  */
 181
 182 static int
 183 cpp_string_eq (const void *a_p, const void *b_p)
 184 {
 185   const struct cpp_string *a = (const struct cpp_string *) a_p;
 186   const struct cpp_string *b = (const struct cpp_string *) b_p;
 187   return (a->len == b->len
 188           && memcmp (a->text, b->text, a->len) == 0);
 189 }
 190
 191 /* Save the current definitions of the cpp_reader for dependency
 192    checking purposes.  When writing a precompiled header, this should
 193    be called at the same point in the compilation as cpp_valid_state
 194    would be called when reading the precompiled header back in.  */
 195
 196 int
 197 cpp_save_state (cpp_reader *r, FILE *f)
 198 {
 199   /* Save the list of non-void identifiers for the dependency checking.  */
 200   r->savedstate = XNEW (struct cpp_savedstate);
 201   r->savedstate->definedhash = htab_create (100, cpp_string_hash,
 202                                             cpp_string_eq, NULL);
 203   cpp_forall_identifiers (r, save_idents, r->savedstate);
 204
 205   /* Write out the list of defined identifiers.  */
 206   cpp_forall_identifiers (r, write_macdef, f);
 207
 208   return 0;
 209 }
 210
 211 /* Calculate the 'hashsize' field of the saved state.  */
 212
 213 static int
 214 count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
 215 {
 216   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
 217
 218   switch (hn->type)
 219     {
 220     case NT_MACRO:
 221       if (hn->flags & NODE_BUILTIN)
 222         return 1;
 223
 224       /* else fall through.  */
 225
 226     case NT_VOID:
 227       {
 228         struct cpp_string news;
 229         void **slot;
 230
 231         news.len = NODE_LEN (hn);
 232         news.text = NODE_NAME (hn);
 233         slot = (void **) htab_find (ss->definedhash, &news);
 234         if (slot == NULL)
 235           {
 236             ss->hashsize += NODE_LEN (hn) + 1;
 237             ss->n_defs += 1;
 238           }
 239       }
 240       return 1;
 241
 242     case NT_ASSERTION:
 243       /* Not currently implemented.  */
 244       return 1;
 245
 246     default:
 247       abort ();
 248     }
 249 }
 250
 251 /* Collect the identifiers into the state's string table.  */
 252 static int
 253 write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
 254 {
 255   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
 256
 257   switch (hn->type)
 258     {
 259     case NT_MACRO:
 260       if (hn->flags & NODE_BUILTIN)
 261         return 1;
 262
 263       /* else fall through.  */
 264
 265     case NT_VOID:
 266       {
 267         struct cpp_string news;
 268         void **slot;
 269
 270         news.len = NODE_LEN (hn);
 271         news.text = NODE_NAME (hn);
 272         slot = (void **) htab_find (ss->definedhash, &news);
 273         if (slot == NULL)
 274           {
 275             ss->defs[ss->n_defs] = hn;
 276             ss->n_defs += 1;
 277           }
 278       }
 279       return 1;
 280
 281     case NT_ASSERTION:
 282       /* Not currently implemented.  */
 283       return 1;
 284
 285     default:
 286       abort ();
 287     }
 288 }
 289
 290 /* Comparison function for qsort.  The arguments point to pointers of
 291    type ht_hashnode *.  */
 292 static int
 293 comp_hashnodes (const void *px, const void *py)
 294 {
 295   cpp_hashnode *x = *(cpp_hashnode **) px;
 296   cpp_hashnode *y = *(cpp_hashnode **) py;
 297   return ustrcmp (NODE_NAME (x), NODE_NAME (y));
 298 }
 299
 300 /* Write out the remainder of the dependency information.  This should be
 301    called after the PCH is ready to be saved.  */
 302
 303 int
 304 cpp_write_pch_deps (cpp_reader *r, FILE *f)
 305 {
 306   struct macrodef_struct z;
 307   struct cpp_savedstate *const ss = r->savedstate;
 308   unsigned char *definedstrs;
 309   size_t i;
 310
 311   /* Collect the list of identifiers which have been seen and
 312      weren't defined to anything previously.  */
 313   ss->hashsize = 0;
 314   ss->n_defs = 0;
 315   cpp_forall_identifiers (r, count_defs, ss);
 316
 317   ss->defs = XNEWVEC (cpp_hashnode *, ss->n_defs);
 318   ss->n_defs = 0;
 319   cpp_forall_identifiers (r, write_defs, ss);
 320
 321   /* Sort the list, copy it into a buffer, and write it out.  */
 322   qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
 323   definedstrs = ss->definedstrs = XNEWVEC (unsigned char, ss->hashsize);
 324   for (i = 0; i < ss->n_defs; ++i)
 325     {
 326       size_t len = NODE_LEN (ss->defs[i]);
 327       memcpy (definedstrs, NODE_NAME (ss->defs[i]), len + 1);
 328       definedstrs += len + 1;
 329     }
 330
 331   memset (&z, 0, sizeof (z));
 332   z.definition_length = ss->hashsize;
 333   if (fwrite (&z, sizeof (z), 1, f) != 1
 334       || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1)
 335     {
 336       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 337       return -1;
 338     }
 339   free (ss->definedstrs);
 340
 341   /* Free the saved state.  */
 342   free (ss);
 343   r->savedstate = NULL;
 344
 345   /* Save the next value of __COUNTER__. */
 346   if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
 347     {
 348       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 349       return -1;
 350     }
 351
 352   return 0;
 353 }
 354
 355 /* Write out the definitions of the preprocessor, in a form suitable for
 356    cpp_read_state.  */
 357
 358 int
 359 cpp_write_pch_state (cpp_reader *r, FILE *f)
 360 {
 361   if (!r->deps)
 362     r->deps = deps_init ();
 363
 364   if (deps_save (r->deps, f) != 0)
 365     {
 366       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 367       return -1;
 368     }
 369
 370   if (! _cpp_save_file_entries (r, f))
 371     {
 372       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 373       return -1;
 374     }
 375
 376   /* Save the next __COUNTER__ value.  When we include a precompiled header,
 377      we need to start at the offset we would have if the header had been
 378      included normally. */
 379   if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
 380     {
 381       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 382       return -1;
 383     }
 384
 385   /* Write saved macros.  */
 386   if (! _cpp_save_pushed_macros (r, f))
 387     {
 388       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
 389       return -1;
 390     }
 391
 392   return 0;
 393 }
 394
 395 static int
 396 _cpp_restore_pushed_macros (cpp_reader *r, FILE *f)
 397 {
 398   size_t count_saved = 0;
 399   size_t i;
 400   struct def_pragma_macro *p;
 401   size_t nlen;
 402   uchar *defn;
 403   size_t defnlen;
 404
 405   if (fread (&count_saved, sizeof (count_saved), 1, f) != 1)
 406     return 0;
 407   if (! count_saved)
 408     return 1;
 409   for (i = 0; i < count_saved; i++)
 410     {
 411       if (fread (&nlen, sizeof (nlen), 1, f) != 1)
 412         return 0;
 413       p = XNEW (struct def_pragma_macro);
 414       memset (p, 0, sizeof (struct def_pragma_macro));
 415       p->name = XNEWVAR (char, nlen + 1);
 416       p->name[nlen] = 0;
 417       if (fread (p->name, nlen, 1, f) != 1)
 418         return 0;
 419       if (fread (&defnlen, sizeof (defnlen), 1, f) != 1)
 420         return 0;
 421       if (defnlen == 0)
 422         p->is_undef = 1;
 423       else
 424         {
 425           defn = XNEWVEC (uchar, defnlen + 1);
 426           defn[defnlen] = 0;
 427
 428           if (fread (defn, defnlen, 1, f) != 1)
 429             return 0;
 430
 431           p->definition = defn;
 432           if (fread (&(p->line), sizeof (source_location), 1, f) != 1)
 433             return 0;
 434           defnlen = 0;
 435           if (fread (&defnlen, sizeof (defnlen), 1, f) != 1)
 436             return 0;
 437           p->syshdr = ((defnlen & 1) != 0 ? 1 : 0);
 438           p->used =  ((defnlen & 2) != 0 ? 1 : 0);
 439         }
 440
 441       p->next = r->pushed_macros;
 442       r->pushed_macros = p;
 443     }
 444   return 1;
 445 }
 446
 447 static int
 448 _cpp_save_pushed_macros (cpp_reader *r, FILE *f)
 449 {
 450   size_t count_saved = 0;
 451   size_t i;
 452   struct def_pragma_macro *p,**pp;
 453   size_t defnlen;
 454
 455   /* Get count. */
 456   p = r->pushed_macros;
 457   while (p != NULL)
 458     {
 459       count_saved++;
 460       p = p->next;
 461     }
 462   if (fwrite (&count_saved, sizeof (count_saved), 1, f) != 1)
 463     return 0;
 464   if (!count_saved)
 465     return 1;
 466
 467   pp = (struct def_pragma_macro **) alloca (sizeof (struct def_pragma_macro *)
 468                                             * count_saved);
 469   /* Store them in reverse order.  */
 470   p = r->pushed_macros;
 471   i = count_saved;
 472   while (p != NULL)
 473     {
 474       --i;
 475       pp[i] = p;
 476       p = p->next;
 477     }
 478   for (i = 0; i < count_saved; i++)
 479     {
 480       defnlen = strlen (pp[i]->name);
 481       if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1
 482           || fwrite (pp[i]->name, defnlen, 1, f) != 1)
 483         return 0;
 484       if (pp[i]->is_undef)
 485         {
 486           defnlen = 0;
 487           if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1)
 488             return 0;
 489         }
 490       else
 491         {
 492           defnlen = ustrlen (pp[i]->definition);
 493           if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1
 494               || fwrite (pp[i]->definition, defnlen, 1, f) != 1)
 495             return 0;
 496           if (fwrite (&(pp[i]->line), sizeof (source_location), 1, f) != 1)
 497             return 0;
 498           defnlen = 0;
 499           defnlen |= (pp[i]->syshdr != 0 ? 1 : 0);
 500           defnlen |= (pp[i]->used != 0 ? 2 : 0);
 501           if (fwrite (&defnlen, sizeof (defnlen), 1, f) != 1)
 502             return 0;
 503         }
 504     }
 505   return 1;
 506 }
 507
 508
 509 /* Data structure to transform hash table nodes into a sorted list */
 510
 511 struct ht_node_list
 512 {
 513   /* Array of nodes */
 514   cpp_hashnode **defs;
 515   /* Number of nodes in the array */
 516   size_t n_defs;
 517   /* Size of the allocated array */
 518   size_t asize;
 519 };
 520
 521 /* Callback for collecting identifiers from hash table */
 522
 523 static int
 524 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
 525                   void *nl_p)
 526 {
 527   struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
 528
 529   if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
 530     {
 531       if (nl->n_defs == nl->asize)
 532         {
 533           nl->asize *= 2;
 534           nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize);
 535         }
 536
 537       nl->defs[nl->n_defs] = hn;
 538       ++nl->n_defs;
 539     }
 540   return 1;
 541 }
 542
 543
 544 /* Return nonzero if FD is a precompiled header which is consistent
 545    with the preprocessor's current definitions.  It will be consistent
 546    when:
 547
 548    - anything that was defined just before the PCH was generated
 549      is defined the same way now; and
 550    - anything that was not defined then, but is defined now, was not
 551      used by the PCH.
 552
 553    NAME is used to print warnings if `warn_invalid_pch' is set in the
 554    reader's flags.
 555 */
 556
 557 int
 558 cpp_valid_state (cpp_reader *r, const char *name, int fd)
 559 {
 560   struct macrodef_struct m;
 561   size_t namebufsz = 256;
 562   unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz);
 563   unsigned char *undeftab = NULL;
 564   struct ht_node_list nl = { 0, 0, 0 };
 565   unsigned char *first, *last;
 566   unsigned int i;
 567   unsigned int counter;
 568
 569   /* Read in the list of identifiers that must be defined
 570      Check that they are defined in the same way.  */
 571   for (;;)
 572     {
 573       cpp_hashnode *h;
 574       const unsigned char *newdefn;
 575
 576       if (read (fd, &m, sizeof (m)) != sizeof (m))
 577         goto error;
 578
 579       if (m.name_length == 0)
 580         break;
 581
 582       /* If this file is already preprocessed, there won't be any
 583          macros defined, and that's OK.  */
 584       if (CPP_OPTION (r, preprocessed))
 585         {
 586           if (lseek (fd, m.definition_length, SEEK_CUR) == -1)
 587             goto error;
 588           continue;
 589         }
 590
 591       if (m.definition_length > namebufsz)
 592         {
 593           free (namebuf);
 594           namebufsz = m.definition_length + 256;
 595           namebuf = XNEWVEC (unsigned char, namebufsz);
 596         }
 597
 598       if ((size_t)read (fd, namebuf, m.definition_length)
 599           != m.definition_length)
 600         goto error;
 601
 602       h = cpp_lookup (r, namebuf, m.name_length);
 603       if (m.flags & NODE_POISONED
 604           || h->flags & NODE_POISONED)
 605         {
 606           if (CPP_OPTION (r, warn_invalid_pch))
 607             cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 608                                 "%s: not used because `%.*s' is poisoned",
 609                                 name, m.name_length, namebuf);
 610           goto fail;
 611         }
 612
 613       if (h->type != NT_MACRO)
 614         {
 615           /* It's ok if __GCC_HAVE_DWARF2_CFI_ASM becomes undefined,
 616              as in, when the PCH file is created with -g and we're
 617              attempting to use it without -g.  Restoring the PCH file
 618              is supposed to bring in this definition *and* enable the
 619              generation of call frame information, so that precompiled
 620              definitions that take this macro into accout, to decide
 621              what asm to emit, won't issue .cfi directives when the
 622              compiler doesn't.  */
 623           if (!(h->flags & NODE_USED)
 624               && m.name_length == sizeof ("__GCC_HAVE_DWARF2_CFI_ASM") - 1
 625               && !memcmp (namebuf, "__GCC_HAVE_DWARF2_CFI_ASM", m.name_length))
 626             continue;
 627
 628           if (CPP_OPTION (r, warn_invalid_pch))
 629             cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 630                                 "%s: not used because `%.*s' not defined",
 631                                 name, m.name_length, namebuf);
 632           goto fail;
 633         }
 634
 635       newdefn = cpp_macro_definition (r, h);
 636
 637       if (m.definition_length != ustrlen (newdefn)
 638           || memcmp (namebuf, newdefn, m.definition_length) != 0)
 639         {
 640           if (CPP_OPTION (r, warn_invalid_pch))
 641             cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 642                "%s: not used because `%.*s' defined as `%s' not `%.*s'",
 643                        name, m.name_length, namebuf, newdefn + m.name_length,
 644                        m.definition_length - m.name_length,
 645                        namebuf +  m.name_length);
 646           goto fail;
 647         }
 648     }
 649   free (namebuf);
 650   namebuf = NULL;
 651
 652   /* Read in the list of identifiers that must not be defined.
 653      Check that they really aren't.  */
 654   undeftab = XNEWVEC (unsigned char, m.definition_length);
 655   if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
 656     goto error;
 657
 658   /* Collect identifiers from the current hash table.  */
 659   nl.n_defs = 0;
 660   nl.asize = 10;
 661   nl.defs = XNEWVEC (cpp_hashnode *, nl.asize);
 662   cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
 663   qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
 664
 665   /* Loop through nl.defs and undeftab, both of which are sorted lists.
 666      There should be no matches.  */
 667   first = undeftab;
 668   last = undeftab + m.definition_length;
 669   i = 0;
 670
 671   while (first < last && i < nl.n_defs)
 672     {
 673       int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
 674
 675       if (cmp < 0)
 676         first += ustrlen (first) + 1;
 677       else if (cmp > 0)
 678         ++i;
 679       else
 680         {
 681           if (CPP_OPTION (r, warn_invalid_pch))
 682             cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 683                                 "%s: not used because `%s' is defined",
 684                                 name, first);
 685           goto fail;
 686         }
 687     }
 688
 689   free(nl.defs);
 690   nl.defs = NULL;
 691   free (undeftab);
 692   undeftab = NULL;
 693
 694   /* Read in the next value of __COUNTER__.
 695      Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
 696      has not been used in this translation unit. */
 697   if (read (fd, &counter, sizeof (counter)) != sizeof (counter))
 698     goto error;
 699   if (counter && r->counter)
 700     {
 701       if (CPP_OPTION (r, warn_invalid_pch))
 702         cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 703                             "%s: not used because `__COUNTER__' is invalid",
 704                             name);
 705         goto fail;
 706     }
 707
 708   /* We win!  */
 709   return 0;
 710
 711  error:
 712   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
 713   return -1;
 714
 715  fail:
 716   if (namebuf != NULL)
 717     free (namebuf);
 718   if (undeftab != NULL)
 719     free (undeftab);
 720   if (nl.defs != NULL)
 721     free (nl.defs);
 722   return 1;
 723 }
 724
 725 /* Save all the existing macros.  */
 726
 727 struct save_macro_data
 728 {
 729   uchar **defns;
 730   size_t count;
 731   size_t array_size;
 732   char **saved_pragmas;
 733 };
 734
 735 /* Save the definition of a single macro, so that it will persist
 736    across a PCH restore.  Because macro data is in GCed memory, which
 737    will be blown away by PCH, it must be temporarily copied to
 738    malloced memory.  (The macros will refer to identifier nodes which
 739    are also GCed and so on, so the copying is done by turning them
 740    into self-contained strings.)  The assumption is that most macro
 741    definitions will come from the PCH file, not from the compilation
 742    before the PCH file is loaded, so it doesn't matter that this is
 743    a little expensive.
 744
 745    It would reduce the cost even further if macros defined in the PCH
 746    file were not saved in this way, but this is not done (yet), except
 747    for builtins, and for #assert by default.  */
 748
 749 static int
 750 save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
 751 {
 752   struct save_macro_data *data = (struct save_macro_data *)data_p;
 753
 754   if ((h->flags & NODE_BUILTIN)
 755       && h->type == NT_MACRO
 756       && r->cb.user_builtin_macro)
 757     r->cb.user_builtin_macro (r, h);
 758
 759   if (h->type != NT_VOID
 760       && (h->flags & NODE_BUILTIN) == 0)
 761     {
 762       if (data->count == data->array_size)
 763         {
 764           data->array_size *= 2;
 765           data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size));
 766         }
 767
 768       switch (h->type)
 769         {
 770         case NT_ASSERTION:
 771           /* Not currently implemented.  */
 772           return 1;
 773
 774         case NT_MACRO:
 775           {
 776             const uchar * defn = cpp_macro_definition (r, h);
 777             size_t defnlen = ustrlen (defn);
 778
 779             data->defns[data->count] = (uchar *) xmemdup (defn, defnlen,
 780                                                           defnlen + 2);
 781             data->defns[data->count][defnlen] = '\n';
 782           }
 783           break;
 784
 785         default:
 786           abort ();
 787         }
 788       data->count++;
 789     }
 790   return 1;
 791 }
 792
 793 /* Prepare to restore the state, by saving the currently-defined
 794    macros in 'data'.  */
 795
 796 void
 797 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
 798 {
 799   struct save_macro_data *d = XNEW (struct save_macro_data);
 800
 801   d->array_size = 512;
 802   d->defns = XNEWVEC (uchar *, d->array_size);
 803   d->count = 0;
 804   cpp_forall_identifiers (r, save_macros, d);
 805   d->saved_pragmas = _cpp_save_pragma_names (r);
 806   *data = d;
 807 }
 808
 809 /* Given a precompiled header that was previously determined to be valid,
 810    apply all its definitions (and undefinitions) to the current state.
 811    DEPNAME is passed to deps_restore.  */
 812
 813 int
 814 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
 815                 struct save_macro_data *data)
 816 {
 817   size_t i;
 818   struct lexer_state old_state;
 819   unsigned int counter;
 820
 821   /* Restore spec_nodes, which will be full of references to the old
 822      hashtable entries and so will now be invalid.  */
 823   {
 824     struct spec_nodes *s = &r->spec_nodes;
 825     s->n_defined        = cpp_lookup (r, DSC("defined"));
 826     s->n_true           = cpp_lookup (r, DSC("true"));
 827     s->n_false          = cpp_lookup (r, DSC("false"));
 828     s->n__VA_ARGS__     = cpp_lookup (r, DSC("__VA_ARGS__"));
 829   }
 830
 831   old_state = r->state;
 832   r->state.in_directive = 1;
 833   r->state.prevent_expansion = 1;
 834   r->state.angled_headers = 0;
 835
 836   /* Run through the carefully-saved macros, insert them.  */
 837   for (i = 0; i < data->count; i++)
 838     {
 839       cpp_hashnode *h;
 840       size_t namelen;
 841       uchar *defn;
 842
 843       namelen = ustrcspn (data->defns[i], "( \n");
 844       h = cpp_lookup (r, data->defns[i], namelen);
 845       defn = data->defns[i] + namelen;
 846
 847       /* The PCH file is valid, so we know that if there is a definition
 848          from the PCH file it must be the same as the one we had
 849          originally, and so do not need to restore it.  */
 850       if (h->type == NT_VOID)
 851         {
 852           if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true)
 853               != NULL)
 854             {
 855               _cpp_clean_line (r);
 856               if (!_cpp_create_definition (r, h))
 857                 abort ();
 858               _cpp_pop_buffer (r);
 859             }
 860           else
 861             abort ();
 862         }
 863
 864       free (data->defns[i]);
 865     }
 866   r->state = old_state;
 867
 868   _cpp_restore_pragma_names (r, data->saved_pragmas);
 869
 870   free (data);
 871
 872   if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
 873       != 0)
 874     goto error;
 875
 876   if (! _cpp_read_file_entries (r, f))
 877     goto error;
 878
 879   if (fread (&counter, sizeof (counter), 1, f) != 1)
 880     goto error;
 881
 882   if (!r->counter)
 883     r->counter = counter;
 884
 885   /* Read pushed macros. */
 886   if (! _cpp_restore_pushed_macros (r, f))
 887     goto error;
 888   return 0;
 889
 890  error:
 891   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
 892   return -1;
 893 }