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   cpp_hashnode *h = NULL;
 403   cpp_macro *m;
 404   uchar *defn;
 405   size_t defnlen;
 406
 407   if (fread (&count_saved, sizeof (count_saved), 1, f) != 1)
 408     return 0;
 409   if (! count_saved)
 410     return 1;
 411   for (i = 0; i < count_saved; i++)
 412     {
 413       if (fread (&nlen, sizeof (nlen), 1, f) != 1)
 414         return 0;
 415       p = XNEW (struct def_pragma_macro);
 416       p->name = XNEWVAR (char, nlen + 1);
 417       p->name[nlen] = 0;
 418       if (fread (p->name, nlen, 1, f) != 1)
 419         return 0;
 420       /* Save old state.  */
 421       m = cpp_push_definition (r, p->name);
 422       if (fread (&defnlen, sizeof (defnlen), 1, f) != 1)
 423         return 0;
 424       defn = XNEWVAR (uchar, defnlen + 2);
 425       defn[defnlen] = '\n';
 426       defn[defnlen + 1] = 0;
 427
 428       if (fread (defn, defnlen, 1, f) != 1)
 429         return 0;
 430       cpp_pop_definition (r, p->name, NULL);
 431       {
 432         size_t namelen;
 433         uchar *dn;
 434
 435         namelen = ustrcspn (defn, "( \n");
 436         h = cpp_lookup (r, defn, namelen);
 437         dn = defn + namelen;
 438
 439         h->type = NT_VOID;
 440         h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED);
 441         if (cpp_push_buffer (r, dn, ustrchr (dn, '\n') - dn, true)
 442             != NULL)
 443           {
 444             _cpp_clean_line (r);
 445             if (!_cpp_create_definition (r, h))
 446               abort ();
 447             _cpp_pop_buffer (r);
 448           }
 449         else
 450           abort ();
 451       }
 452       p->value = cpp_push_definition (r, p->name);
 453
 454       free (defn);
 455       p->next = r->pushed_macros;
 456       r->pushed_macros = p;
 457       /* Restore current state.  */
 458       cpp_pop_definition (r, p->name, m);
 459     }
 460   return 1;
 461 }
 462
 463 static int
 464 _cpp_save_pushed_macros (cpp_reader *r, FILE *f)
 465 {
 466   size_t count_saved = 0;
 467   size_t i;
 468   struct def_pragma_macro *p,**pp;
 469   cpp_hashnode *node;
 470   cpp_macro *m;
 471   size_t defnlen;
 472   const uchar *defn;
 473
 474   /* Get count. */
 475   p = r->pushed_macros;
 476   while (p != NULL)
 477     {
 478       count_saved++;
 479       p = p->next;
 480     }
 481   if (fwrite (&count_saved, sizeof (count_saved), 1, f) != 1)
 482     return 0;
 483   if (!count_saved)
 484     return 1;
 485
 486   pp = (struct def_pragma_macro **) alloca (sizeof (struct def_pragma_macro *)
 487                                             * count_saved);
 488   /* Store them in reverse order.  */
 489   p = r->pushed_macros;
 490   i = count_saved;
 491   while (p != NULL)
 492     {
 493       --i;
 494       pp[i] = p;
 495       p = p->next;
 496     }
 497   for (i = 0; i < count_saved; i++)
 498     {
 499       /* Save old state.  */
 500       m = cpp_push_definition (r, pp[i]->name);
 501       /* Set temporary macro name to saved state.  */
 502       cpp_pop_definition (r, pp[i]->name, pp[i]->value);
 503       node = _cpp_lex_identifier (r, pp[i]->name);
 504       defnlen = strlen (pp[i]->name);
 505       if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1
 506           || fwrite (pp[i]->name, defnlen, 1, f) != 1)
 507         return 0;
 508       defn = cpp_macro_definition (r, node);
 509       defnlen = ustrlen (defn);
 510       if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1
 511           || fwrite (defn, defnlen, 1, f) != 1)
 512         return 0;
 513       /* Restore current state.  */
 514       cpp_pop_definition (r, pp[i]->name, m);
 515     }
 516   return 1;
 517 }
 518
 519
 520 /* Data structure to transform hash table nodes into a sorted list */
 521
 522 struct ht_node_list
 523 {
 524   /* Array of nodes */
 525   cpp_hashnode **defs;
 526   /* Number of nodes in the array */
 527   size_t n_defs;
 528   /* Size of the allocated array */
 529   size_t asize;
 530 };
 531
 532 /* Callback for collecting identifiers from hash table */
 533
 534 static int
 535 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
 536                   void *nl_p)
 537 {
 538   struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
 539
 540   if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
 541     {
 542       if (nl->n_defs == nl->asize)
 543         {
 544           nl->asize *= 2;
 545           nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize);
 546         }
 547
 548       nl->defs[nl->n_defs] = hn;
 549       ++nl->n_defs;
 550     }
 551   return 1;
 552 }
 553
 554
 555 /* Return nonzero if FD is a precompiled header which is consistent
 556    with the preprocessor's current definitions.  It will be consistent
 557    when:
 558
 559    - anything that was defined just before the PCH was generated
 560      is defined the same way now; and
 561    - anything that was not defined then, but is defined now, was not
 562      used by the PCH.
 563
 564    NAME is used to print warnings if `warn_invalid_pch' is set in the
 565    reader's flags.
 566 */
 567
 568 int
 569 cpp_valid_state (cpp_reader *r, const char *name, int fd)
 570 {
 571   struct macrodef_struct m;
 572   size_t namebufsz = 256;
 573   unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz);
 574   unsigned char *undeftab = NULL;
 575   struct ht_node_list nl = { 0, 0, 0 };
 576   unsigned char *first, *last;
 577   unsigned int i;
 578   unsigned int counter;
 579
 580   /* Read in the list of identifiers that must be defined
 581      Check that they are defined in the same way.  */
 582   for (;;)
 583     {
 584       cpp_hashnode *h;
 585       const unsigned char *newdefn;
 586
 587       if (read (fd, &m, sizeof (m)) != sizeof (m))
 588         goto error;
 589
 590       if (m.name_length == 0)
 591         break;
 592
 593       /* If this file is already preprocessed, there won't be any
 594          macros defined, and that's OK.  */
 595       if (CPP_OPTION (r, preprocessed))
 596         {
 597           if (lseek (fd, m.definition_length, SEEK_CUR) == -1)
 598             goto error;
 599           continue;
 600         }
 601
 602       if (m.definition_length > namebufsz)
 603         {
 604           free (namebuf);
 605           namebufsz = m.definition_length + 256;
 606           namebuf = XNEWVEC (unsigned char, namebufsz);
 607         }
 608
 609       if ((size_t)read (fd, namebuf, m.definition_length)
 610           != m.definition_length)
 611         goto error;
 612
 613       h = cpp_lookup (r, namebuf, m.name_length);
 614       if (m.flags & NODE_POISONED
 615           || h->flags & NODE_POISONED)
 616         {
 617           if (CPP_OPTION (r, warn_invalid_pch))
 618             cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 619                                 "%s: not used because `%.*s' is poisoned",
 620                                 name, m.name_length, namebuf);
 621           goto fail;
 622         }
 623
 624       if (h->type != NT_MACRO)
 625         {
 626           /* It's ok if __GCC_HAVE_DWARF2_CFI_ASM becomes undefined,
 627              as in, when the PCH file is created with -g and we're
 628              attempting to use it without -g.  Restoring the PCH file
 629              is supposed to bring in this definition *and* enable the
 630              generation of call frame information, so that precompiled
 631              definitions that take this macro into accout, to decide
 632              what asm to emit, won't issue .cfi directives when the
 633              compiler doesn't.  */
 634           if (!(h->flags & NODE_USED)
 635               && m.name_length == sizeof ("__GCC_HAVE_DWARF2_CFI_ASM") - 1
 636               && !memcmp (namebuf, "__GCC_HAVE_DWARF2_CFI_ASM", m.name_length))
 637             continue;
 638
 639           if (CPP_OPTION (r, warn_invalid_pch))
 640             cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 641                                 "%s: not used because `%.*s' not defined",
 642                                 name, m.name_length, namebuf);
 643           goto fail;
 644         }
 645
 646       newdefn = cpp_macro_definition (r, h);
 647
 648       if (m.definition_length != ustrlen (newdefn)
 649           || memcmp (namebuf, newdefn, m.definition_length) != 0)
 650         {
 651           if (CPP_OPTION (r, warn_invalid_pch))
 652             cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 653                "%s: not used because `%.*s' defined as `%s' not `%.*s'",
 654                        name, m.name_length, namebuf, newdefn + m.name_length,
 655                        m.definition_length - m.name_length,
 656                        namebuf +  m.name_length);
 657           goto fail;
 658         }
 659     }
 660   free (namebuf);
 661   namebuf = NULL;
 662
 663   /* Read in the list of identifiers that must not be defined.
 664      Check that they really aren't.  */
 665   undeftab = XNEWVEC (unsigned char, m.definition_length);
 666   if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
 667     goto error;
 668
 669   /* Collect identifiers from the current hash table.  */
 670   nl.n_defs = 0;
 671   nl.asize = 10;
 672   nl.defs = XNEWVEC (cpp_hashnode *, nl.asize);
 673   cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
 674   qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
 675
 676   /* Loop through nl.defs and undeftab, both of which are sorted lists.
 677      There should be no matches.  */
 678   first = undeftab;
 679   last = undeftab + m.definition_length;
 680   i = 0;
 681
 682   while (first < last && i < nl.n_defs)
 683     {
 684       int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
 685
 686       if (cmp < 0)
 687         first += ustrlen (first) + 1;
 688       else if (cmp > 0)
 689         ++i;
 690       else
 691         {
 692           if (CPP_OPTION (r, warn_invalid_pch))
 693             cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 694                                 "%s: not used because `%s' is defined",
 695                                 name, first);
 696           goto fail;
 697         }
 698     }
 699
 700   free(nl.defs);
 701   nl.defs = NULL;
 702   free (undeftab);
 703   undeftab = NULL;
 704
 705   /* Read in the next value of __COUNTER__.
 706      Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
 707      has not been used in this translation unit. */
 708   if (read (fd, &counter, sizeof (counter)) != sizeof (counter))
 709     goto error;
 710   if (counter && r->counter)
 711     {
 712       if (CPP_OPTION (r, warn_invalid_pch))
 713         cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 714                             "%s: not used because `__COUNTER__' is invalid",
 715                             name);
 716         goto fail;
 717     }
 718
 719   /* We win!  */
 720   return 0;
 721
 722  error:
 723   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
 724   return -1;
 725
 726  fail:
 727   if (namebuf != NULL)
 728     free (namebuf);
 729   if (undeftab != NULL)
 730     free (undeftab);
 731   if (nl.defs != NULL)
 732     free (nl.defs);
 733   return 1;
 734 }
 735
 736 /* Save all the existing macros.  */
 737
 738 struct save_macro_data
 739 {
 740   uchar **defns;
 741   size_t count;
 742   size_t array_size;
 743   char **saved_pragmas;
 744 };
 745
 746 /* Save the definition of a single macro, so that it will persist
 747    across a PCH restore.  Because macro data is in GCed memory, which
 748    will be blown away by PCH, it must be temporarily copied to
 749    malloced memory.  (The macros will refer to identifier nodes which
 750    are also GCed and so on, so the copying is done by turning them
 751    into self-contained strings.)  The assumption is that most macro
 752    definitions will come from the PCH file, not from the compilation
 753    before the PCH file is loaded, so it doesn't matter that this is
 754    a little expensive.
 755
 756    It would reduce the cost even further if macros defined in the PCH
 757    file were not saved in this way, but this is not done (yet), except
 758    for builtins, and for #assert by default.  */
 759
 760 static int
 761 save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
 762 {
 763   struct save_macro_data *data = (struct save_macro_data *)data_p;
 764
 765   if ((h->flags & NODE_BUILTIN)
 766       && h->type == NT_MACRO
 767       && r->cb.user_builtin_macro)
 768     r->cb.user_builtin_macro (r, h);
 769
 770   if (h->type != NT_VOID
 771       && (h->flags & NODE_BUILTIN) == 0)
 772     {
 773       if (data->count == data->array_size)
 774         {
 775           data->array_size *= 2;
 776           data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size));
 777         }
 778
 779       switch (h->type)
 780         {
 781         case NT_ASSERTION:
 782           /* Not currently implemented.  */
 783           return 1;
 784
 785         case NT_MACRO:
 786           {
 787             const uchar * defn = cpp_macro_definition (r, h);
 788             size_t defnlen = ustrlen (defn);
 789
 790             data->defns[data->count] = (uchar *) xmemdup (defn, defnlen,
 791                                                           defnlen + 2);
 792             data->defns[data->count][defnlen] = '\n';
 793           }
 794           break;
 795
 796         default:
 797           abort ();
 798         }
 799       data->count++;
 800     }
 801   return 1;
 802 }
 803
 804 /* Prepare to restore the state, by saving the currently-defined
 805    macros in 'data'.  */
 806
 807 void
 808 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
 809 {
 810   struct save_macro_data *d = XNEW (struct save_macro_data);
 811
 812   d->array_size = 512;
 813   d->defns = XNEWVEC (uchar *, d->array_size);
 814   d->count = 0;
 815   cpp_forall_identifiers (r, save_macros, d);
 816   d->saved_pragmas = _cpp_save_pragma_names (r);
 817   *data = d;
 818 }
 819
 820 /* Given a precompiled header that was previously determined to be valid,
 821    apply all its definitions (and undefinitions) to the current state.
 822    DEPNAME is passed to deps_restore.  */
 823
 824 int
 825 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
 826                 struct save_macro_data *data)
 827 {
 828   size_t i;
 829   struct lexer_state old_state;
 830   unsigned int counter;
 831
 832   /* Restore spec_nodes, which will be full of references to the old
 833      hashtable entries and so will now be invalid.  */
 834   {
 835     struct spec_nodes *s = &r->spec_nodes;
 836     s->n_defined        = cpp_lookup (r, DSC("defined"));
 837     s->n_true           = cpp_lookup (r, DSC("true"));
 838     s->n_false          = cpp_lookup (r, DSC("false"));
 839     s->n__VA_ARGS__     = cpp_lookup (r, DSC("__VA_ARGS__"));
 840   }
 841
 842   old_state = r->state;
 843   r->state.in_directive = 1;
 844   r->state.prevent_expansion = 1;
 845   r->state.angled_headers = 0;
 846
 847   /* Run through the carefully-saved macros, insert them.  */
 848   for (i = 0; i < data->count; i++)
 849     {
 850       cpp_hashnode *h;
 851       size_t namelen;
 852       uchar *defn;
 853
 854       namelen = ustrcspn (data->defns[i], "( \n");
 855       h = cpp_lookup (r, data->defns[i], namelen);
 856       defn = data->defns[i] + namelen;
 857
 858       /* The PCH file is valid, so we know that if there is a definition
 859          from the PCH file it must be the same as the one we had
 860          originally, and so do not need to restore it.  */
 861       if (h->type == NT_VOID)
 862         {
 863           if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true)
 864               != NULL)
 865             {
 866               _cpp_clean_line (r);
 867               if (!_cpp_create_definition (r, h))
 868                 abort ();
 869               _cpp_pop_buffer (r);
 870             }
 871           else
 872             abort ();
 873         }
 874
 875       free (data->defns[i]);
 876     }
 877   r->state = old_state;
 878
 879   _cpp_restore_pragma_names (r, data->saved_pragmas);
 880
 881   free (data);
 882
 883   if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
 884       != 0)
 885     goto error;
 886
 887   if (! _cpp_read_file_entries (r, f))
 888     goto error;
 889
 890   if (fread (&counter, sizeof (counter), 1, f) != 1)
 891     goto error;
 892
 893   if (!r->counter)
 894     r->counter = counter;
 895
 896   /* Read pushed macros. */
 897   if (! _cpp_restore_pushed_macros (r, f))
 898     goto error;
 899   return 0;
 900
 901  error:
 902   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
 903   return -1;
 904 }